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)