def _construct_virtual(parameters: _InterfaceParameters) -> can.ThreadSafeBus:
if isinstance(parameters, _ClassicInterfaceParameters):
return can.ThreadSafeBus(interface=parameters.interface_name,
bitrate=parameters.bitrate)
if isinstance(parameters, _FDInterfaceParameters):
return can.ThreadSafeBus(interface=parameters.interface_name)
assert False, "Internal error"
def _create_bus(self):
name = self._bus_name
if name in (None, 'None', 'none'):
self._bus = NoneBus()
elif name.lower() == 'pcan':
self._bus = can.ThreadSafeBus(bustype='pcan',
bitrate=PEAK_CAN_BIT_RATE)
else:
self._bus = can.ThreadSafeBus(bustype='socketcan',
channel=name,
bitrate=PEAK_CAN_BIT_RATE)
def _construct_socketcan(
parameters: _InterfaceParameters) -> can.ThreadSafeBus:
if isinstance(parameters, _ClassicInterfaceParameters):
return can.ThreadSafeBus(interface=parameters.interface_name,
channel=parameters.channel_name,
fd=False)
if isinstance(parameters, _FDInterfaceParameters):
return can.ThreadSafeBus(interface=parameters.interface_name,
channel=parameters.channel_name,
fd=True)
assert False, "Internal error"
def setUp(self):
self.bus1 = can.ThreadSafeBus(channel=self.CHANNEL_1,
bustype=self.INTERFACE_1,
bitrate=self.BITRATE,
fd=TEST_CAN_FD,
single_handle=True)
self.bus2 = can.ThreadSafeBus(channel=self.CHANNEL_2,
bustype=self.INTERFACE_2,
bitrate=self.BITRATE,
fd=TEST_CAN_FD,
single_handle=True)
def __init__(self, name, config):
super(Plugin, self).__init__(name, config)
self.interface = config['interface']
self.channel = config['channel']
self.buses = []
self.buses.append(
can.ThreadSafeBus(self.channel + '0', bustype=self.interface))
self.buses.append(
can.ThreadSafeBus(self.channel + '1', bustype=self.interface))
self.buses.append(
can.ThreadSafeBus(self.channel + '2', bustype=self.interface))
self.queue = queue.Queue()
def __init__(self):
self.bus = self._can = can.ThreadSafeBus(
channel=settings.CAN_INTERFACE,
bustype='socketcan_ctypes',
can_filters=self._can_filters)
self.__register_notifier()
self.loop = asyncio.new_event_loop()
def init_serial_node():
# Setup serial node
rospy.init_node("serial_node", anonymous=False)
# Setup motor serial and subscriber
# motor_serial = serials["motor"] = serial.Serial(port = '/dev/igvc-nucleo-120', baudrate = 115200)
motor_can = cans["motor"] = can.ThreadSafeBus(bustype='slcan',
channel='/dev/igvc-can-835',
bitrate=100000)
rospy.Subscriber('/igvc/motors_raw', motors, motors_out)
motor_response_thread = VelocityCANReadThread(can_obj=cans["motor"],
topic='/igvc/velocity')
motor_response_thread.start()
# Setup GPS serial and publisher
gps_serial = serials["gps"] = serial.Serial(port='/dev/igvc-nucleo-722',
baudrate=9600)
gps_response_thread = GPSSerialReadThread(serial_obj=serials["gps"],
topic='/igvc/gps')
gps_response_thread.start()
# Wait for topic updates
rospy.spin()
# Close the serial ports when program ends
print("Closing threads")
motor_can.close()
gps_serial.close()
def run(self):
self.bus = can.ThreadSafeBus(self.channel, bustype=self.interface)
for each in self.mapping.output_mapping:
self.db_callback_add(
each, self.mapping.getOutputFunction(self.bus, each,
self.node))
self.thread.start()
def test_thread_based_cyclic_send_task(self):
bus = can.ThreadSafeBus(bustype="virtual")
msg = can.Message(is_extended_id=False,
arbitration_id=0x123,
data=[0, 1, 2, 3, 4, 5, 6, 7])
# good case, bus is up
on_error_mock = MagicMock(return_value=False)
task = can.broadcastmanager.ThreadBasedCyclicSendTask(
bus, bus._lock_send_periodic, msg, 0.1, 3, on_error_mock)
task.start()
sleep(1)
on_error_mock.assert_not_called()
task.stop()
bus.shutdown()
# bus has been shutted down
on_error_mock = MagicMock(return_value=False)
task = can.broadcastmanager.ThreadBasedCyclicSendTask(
bus, bus._lock_send_periodic, msg, 0.1, 3, on_error_mock)
task.start()
sleep(1)
self.assertEqual(on_error_mock.call_count, 1)
task.stop()
# bus is still shutted down, but on_error returns True
on_error_mock = MagicMock(return_value=True)
task = can.broadcastmanager.ThreadBasedCyclicSendTask(
bus, bus._lock_send_periodic, msg, 0.1, 3, on_error_mock)
task.start()
sleep(1)
self.assertTrue(on_error_mock.call_count > 1)
task.stop()
def _construct_kvaser(parameters: _InterfaceParameters) -> can.ThreadSafeBus:
if isinstance(parameters, _ClassicInterfaceParameters):
return can.ThreadSafeBus(
interface=parameters.interface_name,
channel=parameters.channel_name,
bitrate=parameters.bitrate,
fd=False,
)
if isinstance(parameters, _FDInterfaceParameters):
return can.ThreadSafeBus(
interface=parameters.interface_name,
channel=parameters.channel_name,
bitrate=parameters.bitrate[0],
fd=True,
data_bitrate=parameters.bitrate[1],
)
assert False, "Internal error"
def _construct_canalystii(
parameters: _InterfaceParameters) -> can.ThreadSafeBus:
if isinstance(parameters, _ClassicInterfaceParameters):
return can.ThreadSafeBus(interface=parameters.interface_name,
channel=parameters.channel_name,
bitrate=parameters.bitrate)
if isinstance(parameters, _FDInterfaceParameters):
raise InvalidMediaConfigurationError(
f"Interface does not support CAN FD: {parameters.interface_name}")
assert False, "Internal error"
def __init__(self):
"""
Load settings for VN3000
"""
with open("vn3000.json") as f_obj:
templates = json.load(f_obj)
self.dcBlock = templates["presetting"].get("dcBlock")
self.rfBlock = templates["presetting"].get("rfBlock")
self.highVoltageBlock = templates["presetting"].get("highVoltageBlock")
self.pressureTurbine_start = templates["pressureSettings"].get(
"pressureTurbine")
self.pressureSensorPG_enable = templates["pressureSettings"].get(
"pressureIonVacuumi")
try:
if os.name == "nt":
self.bus = can.ThreadSafeBus(bustype="systec",
channel="0",
bitrate=1000000)
else:
os.system(
"echo password|sudo -S ip link set can0 type can bitrate 1000000"
)
os.system("echo password|sudo -S ip link set up can0")
self.bus = can.ThreadSafeBus(channel="can0",
bustype="socketcan")
except can.CanError:
print("Hardware or CAN interface initialization failed.")
input()
self.blk_upr = BlockUPR(self.bus)
self.blk_rasp = BlockRasp(self.bus)
self.blk_dc = BlockDC(self.bus)
self.blk_rf = BlockRF(self.bus)
self.parser = Parser(
blockUpr=self.blk_upr,
blockRasp=self.blk_rasp,
blockDc=self.blk_dc,
blockRf=self.blk_rf,
)
def _construct_pcan(parameters: _InterfaceParameters) -> can.ThreadSafeBus:
if isinstance(parameters, _ClassicInterfaceParameters):
return can.ThreadSafeBus(
interface=parameters.interface_name,
channel=parameters.channel_name,
bitrate=parameters.bitrate,
)
if isinstance(parameters, _FDInterfaceParameters):
# These magic numbers come from the settings of PCAN adapter.
# They don't allow any direct baudrate settings, you have to set all lengths and value of the main frequency.
# Bit lengths below are very universal and can be applied for almost every popular baudrate.
# There is probably a better solution here, but it needs significantly more time to implement it.
f_clock = 40000000
nom_tseg1, nom_tseg2, nom_sjw = 3, 1, 1
data_tseg1, data_tseg2, data_sjw = 3, 1, 1
nom_br = int(f_clock / parameters.bitrate[0] /
(nom_tseg1 + nom_tseg2 + nom_sjw))
data_br = int(f_clock / parameters.bitrate[1] /
(data_tseg1 + data_tseg2 + data_sjw))
# TODO: validate the result and see if it is within an acceptable range
return can.ThreadSafeBus(
interface=parameters.interface_name,
channel=parameters.channel_name,
f_clock=f_clock,
nom_brp=nom_br,
data_brp=data_br,
nom_tseg1=nom_tseg1,
nom_tseg2=nom_tseg2,
nom_sjw=nom_sjw,
data_tseg1=data_tseg1,
data_tseg2=data_tseg2,
data_sjw=data_sjw,
fd=True,
)
assert False, "Internal error"
def create_connection(self):
try:
self.can_bus = can.ThreadSafeBus(bustype="vector",
app_name=self.can_app_name,
channel=self.can_channel,
bitrate=self.can_bitrate)
self.func_transmit = Thread(target=self.process_message,
args=(self.lock, ))
self.func_transmit.daemon = True
self.func_receive = Thread(target=self.receive_message)
self.func_receive.daemon = True
return True
except Exception as e:
print("Error Occured", e)
return False
def __init__(self, interface, br):
if interface:
self._can_bus = can.ThreadSafeBus(
bustype="socketcan",
channel=interface,
bitrate=br,
receive_own_messages=True,
)
else:
self._can_bus = None
self._filter_rules = []
self._nodes = []
self._history = []
self._loop = None
self._notifier = None
def connectCan():
global bus
if app.config['FEATURE']['can']:
try:
#bus = can.interface.Bus(app.config['CAN']['interface'], bustype=app.config['CAN']['type'])
bus = can.ThreadSafeBus('ws://192.168.1.11:54701/',
bustype='remote',
bitrate=500000,
receive_own_messages=True)
#can_buffer = can.BufferedReader()
#notifier = can.Notifier(bus, [can_buffer], timeout=0.1)
print("CAN bus connected")
return True
except BaseException as e:
#print("CAN bus error: %s" % e)
return e
def set_can(self, interface, channel, bitrate, db=None, test_name=None):
""" Set the CAN BUS
Keyword arguments:
interface -- can interface (socketcan, vector, ...)
channel -- can channel (can0, vcan0, ...)
bitrate -- can bitrate (125000, 500000, ...)
db -- can database (arxml,dbc,kcd,sym,cdd)
test_name -- Name of test case
See https://cantools.readthedocs.io/en/latest/#about
See https://python-can.readthedocs.io/en/master/interfaces.html
"""
dt_now = dt.datetime.now()
self.interface = interface
self.channel = channel
self.bitrate = bitrate
self.db_file = db
self.bus = can.interface.Bus(bustype=self.interface,
channel=self.channel,
bitrate=self.bitrate)
self.logbus = can.ThreadSafeBus(interface=self.interface,
channel=self.channel)
if db is not None and db != 'None':
self.db = cantools.database.load_file(db)
self.db_default_node = self.db.nodes[0].name
path = os.getcwd()
path = path + "/outputs/" + ("%d%02d%02d/" %
(dt_now.year, dt_now.month, dt_now.day))
try:
os.mkdir(path)
except FileExistsError:
pass
output_candump_filename = path + (
"%s_%d%02d%02d_%02d%02d%02d" %
(test_name, dt_now.year, dt_now.month, dt_now.day, dt_now.hour,
dt_now.minute, dt_now.second))
self.logger = can.Logger(output_candump_filename)
self.notifier = can.Notifier(self.logbus, [self.logger])
self.is_set = True
def connect(self):
try:
self.bus = can.ThreadSafeBus(interface='socketcan',
channel=self._port,
bitrate=self._bitrate,
receive_own_message=True)
valid, data = self.canopen_sdo(
_CANBUS_ADDRESS_READ_FIRMWARE_REVISION_HI)
if valid:
firmware_version_hi = struct.unpack('=HH', data)[0]
self.firmware_version_number = firmware_version_hi
rospy.loginfo(
f'firmware_version_hi: {firmware_version_hi:04X}')
self.is_connected = True
return True
else:
self.is_connected = False
return False
except (can.exceptions.CanInterfaceNotImplementedError,
can.exceptions.CanInitializationError, ValueError) as e:
rospy.logerr(f'RCU CANbus connection failed: {e}')
self.is_connected = False
return False
def __init__(self, can_device: str, bit_rate: int):
"""
Args:
can_device: Device to communicate over as listed in ifconfig
bit_rate: Effective CAN bus communication speed
"""
# CAN related variables
self._bus = can.ThreadSafeBus(bustype='socketcan',
channel=can_device,
bitrate=bit_rate)
self._default_reader = can.BufferedReader()
self._message_notifier = can.Notifier(self._bus,
[self._default_reader])
# Internal thread related variables
self._data_lock = RLock()
self._kill_event = Event()
self._reader_thread = Thread(target=self._can_message_handler)
self._rx_message_callbacks = {"active_ids": []}
self._periodic_messages = []
# Kick things off!
self._reader_thread.start()
atexit.register(self.shutdown)
help="dbc file to import messages from.",
type=lambda x: is_valid_file(parser, x))
parser.add_argument("-r",
"--random",
help="run cangen while this script is running",
action='store_true')
args = parser.parse_args()
return args
def signal_handler(sig, frame):
os.system('stty echo')
sys.exit(0)
if __name__ == "__main__":
signal.signal(signal.SIGINT, signal_handler)
args = getArgs()
bustype = 'socketcan'
#filters = [{"can_id": 0x118, "can_mask": 0xFF8, "extended": False}]
bus = can.ThreadSafeBus(args.socket, bustype=bustype)
controller = Control(args.dbc, bus)
if not args.random:
subprocess.Popen(["cangen", args.socket, "-L", "8", "-g", "50"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
m = MainLoop(controller, args.socket)
m.mainLoop()
def __init__(self):
self._can = can.ThreadSafeBus(channel=settings.CAN_INTERFACE,
bustype='socketcan_ctypes',
can_filters=self._can_filters)
def __init__(self):
self._bus = can.ThreadSafeBus(bustype='socketcan',
channel='vcan0',
bitrate=500000)
self._recv_queue = queue.Queue()
self._recv_return_queue = {}
import can
import asyncio
from bitstring import BitArray
from bitstring import Bits
import utils.TextDecoder as TextDecoder
import curses
can0 = can.ThreadSafeBus(channel = 'vcan0', bustype = 'socketcan_ctypes')
can0.set_filters([
{
'can_id': 0x5E7,
'can_mask': 0x7FF,
'extended': False
}
])
txt = ''
screen = curses.initscr()
curses.noecho()
curses.cbreak()
screen.keypad(True)
instrumentPanelWindow = curses.newwin(6, 20, 0, 0)
instrumentPanelWindow.border()
screen.refresh()
import can vcan = can.ThreadSafeBus(channel='vcan', bustype='virtual')
while True:
msg = await socketcan_producer.get_message()
msg = can.interfaces.socketcan.socketcan.build_can_frame(
msg) # Convert from can.Message to bytes
try:
await websocket.send(msg)
except websockets.exceptions.ConnectionClosed:
break
notifier.remove_listener(socketcan_producer)
async def websocket_handler(websocket, path):
consumer_task = asyncio.ensure_future(
websocket_consumer_handler(websocket, path))
producer_task = asyncio.ensure_future(
websocket_producer_handler(websocket, path))
done, pending = await asyncio.wait([consumer_task, producer_task],
return_when=asyncio.FIRST_COMPLETED)
for task in pending:
task.cancel()
can_bus = can.ThreadSafeBus(CAN_INTERFACE, bustype="socketcan")
notifier = can.Notifier(can_bus, [], loop=asyncio.get_event_loop())
websocket_server = websockets.serve(websocket_handler,
WEBSOCKET_SERVER_IP_ADDRESS,
WEBSOCKET_SERVER_PORT,
compression=None)
asyncio.get_event_loop().run_until_complete(websocket_server)
asyncio.get_event_loop().run_forever()
def run(self):
for i in range(1000):
msg = can.Message(arbitration_id=0x123, data=[i//256, i%256], is_extended_id=False) # id length is 11
self.transmit(msg)
time.sleep(0.1)
# example 2
class SimpleListenerNode(CanNode):
def rx_callback(self, msg):
print("RECEIVED: " + self._name + ": " + str(msg))
# terminate processes after t seconds
def terminate_after(t, procs):
time.sleep(t)
for p in procs:
p.terminate()
# main function
if __name__ == '__main__':
bus = can.ThreadSafeBus(bustype='socketcan', channel='can0', bitrate=1000000)
notifer = can.Notifier(bus, [])
can_nodes = [ SimpleSenderNode("Sender1", bus, notifer), SimpleListenerNode("Listener1", bus, notifer),]
# run all nodes concurrently
with multiprocessing.Pool() as pool:
for n in can_nodes:
pool.apply_async(n.start())
#pool.apply_async(terminate_after(10, can_nodes)) # terminate after 10s
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(GPIO_LCD_POWER, GPIO.OUT)
GPIO.setup(GPIO_LCD_BACKLIGHT, GPIO.OUT)
# activate the CAN driver
logging.info("Enabling {} driver...".format(CHANNEL))
os.system("sudo /sbin/ip link set {} up type can bitrate {}".format(
CHANNEL, BITRATE))
time.sleep(0.1)
# create bus instance
try:
bus = can.ThreadSafeBus(
bustype='socketcan_native',
channel=CHANNEL,
bitrate=BITRATE,
)
except OSError:
logging.error("Bus {} is error.".format(CHANNEL))
exit()
else:
logging.info("Bus {} is ready.".format(CHANNEL))
# disable ntp sync
os.system("sudo timedatectl set-ntp no")
time.sleep(0.1)
# make RTOS
thRxCan = threading.Thread(target=threadRxCan)
thUsbMonitor = threading.Thread(target=threadUsbMonitor)
