def testBufferedListenerReceives(self): a_listener = can.BufferedReader() a_listener(generate_message(0xDADADA)) a_listener(generate_message(0xDADADA)) self.assertIsNotNone(a_listener.get_message(0.1)) a_listener.stop() self.assertIsNotNone(a_listener.get_message(0.1))
def __init__(self, ui): self.ui = ui self.bus = can.interface.Bus('infotainment', bustype='virtual') self.listener = can.BufferedReader() self.notifier = can.Notifier(self.bus, [self.listener]) self.caniterator = CANIterator(self, self.listener) self.caniterator.start()
def read_msg_listener(can_interface): """ basic listener """ bus = can.interface.Bus(channel=can_interface, bustype=bustype) listener = can.Listener() """ msg = bus.recv() if msg is None: print("Timeout accured, no message is recieved.") else: print(msg) """ reader = can.BufferedReader() # reader is a Listener notifier = can.Notifier(bus, [reader]) #time.sleep(10) msg = None while msg is None: msg = reader.get_message() # as a parameter can be Timeout -> # now either call print(msg) listener(msg) # or listener.on_message_received(msg) print(msg) time.sleep(10) listener.stop()
def testBufferedListenerReceives(self): a_listener = can.BufferedReader() notifier = can.Notifier(self.bus, [a_listener]) m = a_listener.get_message(0.2) self.bus.send(generate_message(0xDADADA)) sleep(0.50) self.assertIsNotNone(m)
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 test_single_bus(self): bus = can.Bus('test', bustype='virtual', receive_own_messages=True) reader = can.BufferedReader() notifier = can.Notifier(bus, [reader], 0.1) msg = can.Message() bus.send(msg) self.assertIsNotNone(reader.get_message(1)) notifier.stop()
def test_single_bus(self): with can.Bus("test", interface="virtual", receive_own_messages=True) as bus: reader = can.BufferedReader() notifier = can.Notifier(bus, [reader], 0.1) msg = can.Message() bus.send(msg) self.assertIsNotNone(reader.get_message(1)) notifier.stop()
def test_basics(self): reader = can.BufferedReader() notifier = can.Notifier(self.bus2, [reader]) message = can.Message(arbitration_id=0x4321, data=[1, 2, 3], extended_id=True) self.bus1.send(message) self.assertEqual(message, reader.get_message(timeout=2.0)) notifier.stop()
def __init__(self, channel): """Open connection with Vector hardware on selected channel, channel is 0 based""" xcp_rx_id = 0x1CE9F827 can_filters = [{"can_id": 0x1CE9F827, "can_mask": 0x0, "extended": True}] self.bus = VectorBus(channel=[channel], app_name='CANoe', can_filters=can_filters) # can_filters = [{"can_id": xcp_rx_id, "can_mask": 0xFFFFFFFF, "extended": True}] # self.bus.set_filters(can_filters) # self.reader = can.BufferedReader() self.notifier = can.Notifier(self.bus, [can.BufferedReader()])
def try_run(self): br = can.BufferedReader() notifier = can.Notifier(self.bus, [br]) audio_channel = None date_sync = False while self.should_run: message = br.get_message(1) if message is not None: arbid = "{0:08x}".format(message.arbitration_id).upper() payload = ba(message.data) #print("From {}: {}".format(arbid, payload)) if message.arbitration_id == CANID_BODY_BUTTONS: # buttons if payload & MASK_BUTTON_VOLUME_UP == MASK_BUTTON_VOLUME_UP: self.buttons.debounce('vol+') if payload & MASK_BUTTON_VOLUME_DN == MASK_BUTTON_VOLUME_DN: self.buttons.debounce('vol-') if payload & MASK_BUTTON_WINDOWS == MASK_BUTTON_WINDOWS: self.buttons.debounce('win') if payload & MASK_BUTTON_MUTE == MASK_BUTTON_MUTE: self.buttons.debounce('mute') if payload & MASK_BUTTON_UP == MASK_BUTTON_UP: self.buttons.debounce('up') if payload & MASK_BUTTON_DOWN == MASK_BUTTON_DOWN: self.buttons.debounce('down') if payload & MASK_BUTTON_MENU == MASK_BUTTON_MENU: self.buttons.debounce('menu') if payload & MASK_BUTTON_SOURCE == MASK_BUTTON_SOURCE: self.buttons.debounce('src') elif message.arbitration_id == CANID_4003_CLOCK: if not date_sync: payload_str = payload.__str__() formatted_date = "{}-{}-{} {}:{}:00".format( payload_str[10:14], payload_str[8:10], payload_str[6:8], payload_str[2:4], payload_str[4:6]) os.system('sudo date -s "{}"'.format(formatted_date)) date_sync = True elif message.arbitration_id == CANID_RADIO_AUDIOCH: prev_audio_channel = audio_channel if payload & MASK_RADIO_AUDIOCH_MPPLAYING == MASK_RADIO_AUDIOCH_MPPLAYING: audio_channel = 'bm' else: audio_channel = 'fm' if prev_audio_channel != audio_channel: self.fire_event('audio_channel', audio_channel) notifier.stop()
def initCAN(self): try: # send out command to set up can0 from the shell to interface CAN controller hardware call('sudo ip link set can0 up type can bitrate 500000', shell=True) # initialize Bus object self.bus = Bus(channel='can0', bustype='socketcan_native') # initialize message buffer to store incoming CAN messages self.bufferedReader = can.BufferedReader() # notifier will notify when new message arrives on the bus and places it in the buffer self.notifier = can.Notifier(self.bus, [self.bufferedReader]) except: print(traceback.print_exc())
def __init__(self): print("Initializing CANbus") # create a bus instance # many other interfaces are supported as well (see below) self.bus = can.Bus(interface='socketcan', channel='vcan0', receive_own_messages=True) self.db = cantools.database.load_file('Sample.dbc') self.example_message = self.db.get_message_by_name('ExampleMessage') self.test_message = self.db.get_message_by_name('Message1') self.buffer = can.BufferedReader() self.notifier = can.Notifier(self.bus, [_get_message, self.buffer])
def initCAN(): global bus global listener global notifier can.rc['interface'] = 'socketcan' can.rc['bitrate'] = 500000 can.rc['channel'] = 'can0' try: bus = Bus() listener = can.BufferedReader() notifier = can.Notifier(bus, [listener]) except Exception as e: print ('ERR: ' + str(e))
def test_multiple_bus(self): bus1 = can.Bus(0, bustype='virtual', receive_own_messages=True) bus2 = can.Bus(1, bustype='virtual', receive_own_messages=True) reader = can.BufferedReader() notifier = can.Notifier([bus1, bus2], [reader], 0.1) msg = can.Message() bus1.send(msg) time.sleep(0.1) bus2.send(msg) recv_msg = reader.get_message(1) self.assertIsNotNone(recv_msg) self.assertEqual(recv_msg.channel, 0) recv_msg = reader.get_message(1) self.assertIsNotNone(recv_msg) self.assertEqual(recv_msg.channel, 1) notifier.stop()
def message(): try: # Initalizes can bus bus = can.interface.Bus(channel=channel, bustype="socketcan_native") # Creates a device that can be used to get messages from the canbus buffRead = can.BufferedReader() # Creates a device that logs all canbus messages to a csv file # NOTE: encodes data in base64 logger = can.CSVWriter("log.csv") """ Creates a notifier object which accepts an array of objects of the can.Listener class Whenever it receves a message from bus it calls the Listeners in the array and lets them handle the message. """ notifier = can.Notifier(bus, [buffRead, logger], timeout=1) except OSError: print("Interface " + channel + " Down.") exit() while True: message = buffRead.get_message() if (message is not None): newData = base64.b64encode(message.data) # This is a hack, newData = base64.b64decode(newData) # convert byte array to bytes. lst = interpret.interpret(message.arbitration_id, newData) if (lst == ""): continue for x in lst: m = None if x[2] == "float": m = struct.unpack('f', x[1].to_bytes( 4, byteorder="little"))[0] elif x[2] == "boolean": if x[1] == 1: m = True else: m = False elif x[2] == "int": m = x[1] else: raise RuntimeError("Unknown type received from interpret: " + x[2]) dictionary[x[0]] = m dictionary["netPower"] = dictionary["batteryPackCurrent"] * dictionary["batteryPackInstantaneousVoltage"] # TODO - Compute net power dictionary["timeSent"] = str(datetime.datetime.now()) # Closes the notifer which closes the Listeners as well notifier.stop()
def __init__(self): """ sock = socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW) interface = "vcan0" try: sock.bind((interface,)) except OSError: sys.stderr.write("Could not bind to interface '%s'\n" % interface) do something about the error... """ self.bus = can.Bus(interface='socketcan', channel='vcan0', receive_own_messages=True) self.buffer = can.BufferedReader() self.notifier = can.Notifier(self.bus, [_get_message, self.buffer]) self.db = cantools.database.load_file('Sample.dbc') self.example_message = self.db.get_message_by_name('ExampleMessage') self.test_message = self.db.get_message_by_name('Message1')
def read_canbus(filename=None): if filename is None: bus = Bus() listener = can.BufferedReader() while True: msg = bus.recv(timeout=1) listener.on_message_received(msg=msg) tmp_msg = listener.get_message(timeout=0.1) if tmp_msg: nmea_msg = NmeaMessage(tmp_msg.timestamp, tmp_msg.arbitration_id, tmp_msg.dlc, tmp_msg.data) print(nmea_msg.convert_to_actisense()) else: with open(filename) as test_file: for line in test_file: print(line)
def init(self, do_calibration=False): self.bus = can.interface.Bus(channel=self.channel, bustype=self.bustype) self.buffer = can.BufferedReader() self.notifier = can.Notifier(self.bus, [self._get_message, self.buffer]) self.serial_number = self.get_serial_number() self.firmware_version = self.get_firmware_version() self.counts_per_force, self.counts_per_torque = self.get_counts_per_unit( ) self.force_unit, self.torque_unit = self.get_units() if do_calibration: self.calibrate_sensor() else: self.calib_matrix = np.zeros([6, 6], dtype=np.float32) self.is_calibrated = False self.bias = np.zeros([6], dtype=np.float32)
def get_bus_data(channel=None): """Returns the memoized ChannelData for a given channel""" if channel is None: channel = default_channel if channel not in channels_to_data: bus = can.interface.Bus(bustype="socketcan", channel=channel, bitrate=CAN_BITRATE) # We use a BufferedReader rather than reading straight from the Bus to prevent the scenario # where the time for the second message to be tx'd exceeds the time taken to process the # first message and start listening for the second one, which occurs if the C side is fast # enough. By buffering, we never miss a message. reader = can.BufferedReader() notifier = can.Notifier(bus, [reader]) channels_to_data[channel] = ChannelData(bus, reader, notifier) return channels_to_data[channel]
def _worker(self): self._worker_queue = Queue() #Create worker queue bus = CanMessages.CANInit(systemParams.canRate) CanMessages.setupGPIO() a_listener = can.BufferedReader() #Create a listener notifier = can.Notifier(bus, [a_listener]) #Create a notifier print("NOTIFIER DONE") _string_messages = CanMessages.StringData() while True: print("IN WHILE") m = a_listener.get_message( 0.25) #Check to see if a message was received if m is not None: #If no message received, "None" is returned message = m.data message = CanMessages.reverseByteOrder(message) self._worker_queue.put(message, True) getThrottle() getSteering()
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)
def __init__(self): rospy.init_node('read_pos', anonymous=True) self.bus = can.Bus(channel='0', bustype="kvaser", bitrate=500000) self.buffer = can.BufferedReader() self.sampling_freq = 30 self.notifier = can.Notifier(self.bus, [_get_message, self.buffer]) self.insertion = np.array([0.0]) self.RX_PDO = 0x1A1 self.POS = Float64MultiArray() self.POS.data = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]) self.time = rospy.get_time() self.pub = rospy.Publisher("pos_actual", Float64MultiArray, queue_size=10) self.pot_ratio = { 0: 4 / 614400, 1: 0.0415, 2: 0.0412, 3: 0.0418, 4: 0.0447, 5: 0.0413, 6: 0.0413 } self.pub.publish(self.POS)
import can import datetime bus = can.interface.Bus("can0", bustype = "socketcan") a_listener = can.BufferedReader() notifier = can.Notifier(bus, [a_listener]) counter = 0 counter_files = 0 filename = str(datetime.datetime.now().strftime('%Y%m%d_%H%M%S')).replace(" ", "-")[:19] signals = [] while True: export_name = filename + "_" + str(counter_files) + ".log" m = a_listener.get_message(0.5) counter+=1 signals.append(str(m) + "\n") if(counter ==5000): with open(export_name, "w") as f: f.writelines(signals) signals = [] counter = 0 counter_files+=1 #@reboot cd /home/pi/py_aut/listenery && /usr/bin/python3.5 logfiles_listener.py
# see http://python-can.readthedocs.io/en/latest/configuration.html #bus = can.interface.Bus() # Using specific buses works similar: bus = can.interface.Bus(bustype='socketcan', channel='vcan0', bitrate=250000) # bus = can.interface.Bus(bustype='pcan', channel='PCAN_USBBUS1', bitrate=250000) # bus = can.interface.Bus(bustype='ixxat', channel=0, bitrate=250000) # bus = can.interface.Bus(bustype='vector', app_name='CANalyzer', channel=0, bitrate=250000) # ... bus.set_filters([{ "can_id": 0x1FFEF1FF, "can_mask": 0x00FFFF00, "extended": True }]) recorder = can.BufferedReader() notifier = can.Notifier(bus, [recorder]) data = np.array([]) data_point = 0 max_data_points = 1000 fig = plt.figure() ax1 = fig.add_subplot(1, 1, 1) plt.xlabel('Sample') plt.ylabel('Speed [km/hr]') plt.grid(True) x = []
# coding:utf-8 from kivy.app import App from kivy.uix.widget import Widget from kivy.clock import Clock import os import time import settings.app_settings as app_settings try: import can os.system("sudo /sbin/ip link set can0 up type can bitrate 500000") #filters = [{"can_id": 0x123, "can_mask": 0x7FF}] bus = can.interface.Bus(channel='can0', bustype='socketcan') bufferedReader = can.BufferedReader() notifier = can.Notifier(bus, [bufferedReader]) except Exception as e: print('CAN setup error:') print(e) class CANcom(Widget): def __init__(self, dio_module, flame_detect, stack_temp, syrup_temp, **kwargs): super(CANcom, self).__init__(**kwargs) self.can_read_data = 0 self.can_write_data = 0 self.can_event = Clock.schedule_interval(self.can_read, 0.01) self.msg0 = self.msg1 = self.msg2 = 0 self.write_can_data = False self.dio_module = dio_module
def __init__(self): # Can bus properties for can0 self.channel = 'can0' self.bustype = 'socketcan' self.bitrate = 1000000 # Adjust everything except ecu to this speed or reprogramm tire temperature sensors # Can bus properties for can1 self.channel = 'can1' self.bitrate = 500000 # ECU can only run upto 500 kbits/sec, I don't remember it working with 1 Mbit/sec self.bus = can.interface.Bus(channel=self.channel, bustype=self.bustype, bitrate=self.bitrate) self.reader = can.BufferedReader() #self.logger = can.Logger('logfile.asc') Can be used for logging without ros self.listeners = [self.reader] #, self.logger] self.notifier = can.Notifier(self.bus, self.listeners) # Initilize custom messages self.tire_msg = tire_t() self.ecu_msg = ecu_msg() # Initizile ros publsihers and set rate of the main loop rospy.init_node('can_driver', anonymous=True) can_pub = rospy.Publisher("can_data", tire_t, queue_size=100) ecu_pub = rospy.Publisher('ecu_data', ecu_msg, queue_size=100) rate = rospy.Rate(100) # Initilize fixed value list for data self.tire_id = [i for i in range(1200, 1212 + 1)] self.avr_t = [0, 0, 0, 0] self.tireT_out = [0 for i in range(0, 16)] self.ecu_out = [0 for i in range(0, 16)] ecu_arbitaions = [ 218099784, 218100296, 218100552, 218100808, 218101064, 218102856 ] n_steps = 0 def dec_converter(msb, lsb): dec = 256 * msb + (lsb / 16) * 16 + lsb // 16 return dec def tire_temp(tTemp): tTemp = tTemp / 10 - 100 return tTemp def tireT_arbitation_filter(canid): #take first readings per channel and assign them accordingly msb = msg.data[0] lsb = msg.data[1] tmp = tire_temp(dec_converter(msb, lsb)) # Switcher use is not optimal for data output # can set a list from case # values drift when bus drops # switcher = { # 1204: self.out[0] = tmp, # 1205: self.out[1] = tmp, # 1206: self.out[2] = tmp, # 1207: self.out[3] = tmp # } #Switcher for tire temperature (1200, 1216) # switcher = {} # for i in range(1204, 1207 + 1): # switcher[i] = tmp # out = {canid: switcher.get(canid, "nothing")} # Will look ugly but works # Look for elegant way to create bunch of function in a loop #list of list is easier to output in ros than dictionery # if canid == 1204: # self.out[0] = ["1204:", tmp] # elif canid == 1205: # self.out[1] = ["1205:", tmp] # elif canid == 1206: # self.out[2] = ["1206:", tmp] # elif canid == 1207: # self.out[3] = ["1207:", tmp] for i in self.tire_id: if i == canid: #self.tireT_out[i - 1200] = [str(i) + ":", tmp] self.tireT_out[i - 1200] = tmp print self.tireT_out # Assign average temperature per sensor self.tire_msg.avr_t_1200 = sum(self.tireT_out[0:4]) / 4 self.tire_msg.avr_t_1204 = sum(self.tireT_out[5:8]) / 4 self.tire_msg.avr_t_1208 = sum(self.tireT_out[9:12]) / 4 self.tire_msg.avr_t_1212 = sum(self.tireT_out[13:16]) / 4 def ecu_arbitation_filter(canid): #ECU lsb to msb, [0],[1] if canid == 218101064: Voltage = dec_converter(msg.data[1], msg.data[0]) AirT = dec_converter(msg.data[3], msg.data[2]) self.ecu_out[0] = [Voltage * 0.01, AirT * 0.1] self.ecu_msg.Battery_Voltage = Voltage self.ecu_msg.ait_T = AirT # Get analog inputs elif canid == 218100296: analog1_4 = [ (dec_converter(msg.data[i + 1], msg.data[i]) * 0.001) for i in range(0, 4) ] self.ecu_out[1] = ["analog1_4:", analog1_4] self.ecu_msg.analog1_4 = analog1_4 elif canid == 218100552: analog5_8 = [ (dec_converter(msg.data[i + 1], msg.data[i]) * 0.001) for i in range(0, 4) ] self.ecu_out[2] = ["analog5_8:", analog5_8] self.ecu_msg.analog5_8 = analog5_8 #Get wheel speed data elif canid == 218100808: freq1_4 = [(dec_converter(msg.data[i + 1], msg.data[i]) * 0.02) for i in range(0, 4)] self.ecu_out[3] = ["freq1_4:", freq1_4] self.ecu_msg.freq1_4 = freq1_4 elif canid == 218099784: RPM = dec_converter(msg.data[1], msg.data[0]) TPS = dec_converter(msg.data[3], msg.data[2]) self.ecu_out[4] = [RPM, TPS * 0.1] self.ecu_msg.RPM = RPM self.ecu_msg.TPS = TPS # for i in ecu_arbitaions: # if canid = ecu_arbitaions[i]: #rospy.loginfo(self.out) #can_pub.publish(str(self.out[0][1204])) #print self.ecu_out while not rospy.is_shutdown(): n_steps += 1 msg = self.reader.get_message() if msg is not None: msg_id = msg.arbitration_id ecu_arbitation_filter(msg_id) tireT_arbitation_filter(msg_id) # Limit message publish rate if (n_steps + 1) % 100 == 0: ecu_pub.publish(self.ecu_msg) can_pub.publish(self.tire_msg)
def __init__(self, channel, bustype='socketcan'): self.bus = can.interface.Bus(channel=channel, bustype=bustype, bitrate=1000000) self.buffer = can.BufferedReader() self.verbose = rospy.get_param('can_comm/verbose', False)
def init_can_listener(self): self.can_listener = can.BufferedReader() self.notifier = can.Notifier(self.bus, [self.can_listener])
if __name__ == '__main__': faulthandler.enable() # network settings channel = "vcan0" # bitrate = 128000 # 128000 if useing can0 dictionary = {} print("CAN RECV test") try: # Initalizes can bus bus = can.interface.Bus(channel=channel, bustype="socketcan_native") # Creates a device that can be used to get messages from the canbus buffRead = can.BufferedReader() # Creates a device that logs all canbus messages to a csv file # NOTE: encodes data in base64 logger = can.CSVWriter("test.csv") """ Creates a notifier object which accepts an array of objects of the can.Listener class Whenever it receves a message from bus it calls the Listeners in the array and lets them handle the message. """ notifier = can.Notifier(bus, [buffRead, logger], timeout=1) except OSError: print("Interface " + channel + " Down.") exit() print("x") loop = asyncio.get_event_loop()
def start(): FORMAT = '%(asctime)-15s %(message)s' logging.basicConfig(format=FORMAT, level=logging.DEBUG) if Config.log_file: logger = logging.getLogger() handler = TimedRotatingFileHandler(Config.log_file, when="midnight", interval=1, backupCount=5) logger.addHandler(handler) logging.info("Starting CAN bus") if not Config.canbus_type: logging.error("No can interface specified. Valid interfaces are: %s" % can.interface.can.VALID_INTERFACES) sys.exit(1) try: bus = can.interface.Bus(Config.canbus_interface, bustype=Config.canbus_type) can_buffer = can.BufferedReader() notifier = can.Notifier(bus, [can_buffer], timeout=0.1) except BaseException as e: logging.error("CAN bus error: %s" % e) sys.exit(1) logging.info("Starting MQTT (" + Config.mqtt_broker + ":" + Config.mqtt_broker_port + ")") mqtt_client = mqtt.Client(client_id=Config.mqtt_client_id, protocol=mqtt.MQTTv31) mqtt_client.on_message = lambda client, userdata, mqtt_message: on_mqtt_message( bus, client, userdata, mqtt_message) try: mqtt_errno = mqtt_client.connect(Config.mqtt_broker, Config.mqtt_broker_port, 60) if mqtt_errno != 0: logging.error("Failed to connect to MQTT " + mqtt.error_string(mqtt_errno)) raise Exception(mqtt.error_string(mqtt_errno)) mqtt_client.loop_start() except BaseException as e: logging.error("MQTT error: %s" % e) bus.shutdown() notifier.stop() return try: for i in range(1, Config.mqtt_topic_iterator1_max + 1): for j in range(1, Config.mqtt_topic_iterator2_max + 1): for k in range(1, Config.mqtt_topic_iterator3_max + 1): subscription_topic = Config.mqtt_topic_template % ( i, j, k, "cmd/power") logging.info("Adding MQTT subscription to '%s'" % subscription_topic) mqtt_client.subscribe(subscription_topic) except BaseException as e: logging.error("Error adding subscribtion \"%s\": %s" % (Config.mqtt_topic_template, e)) return if Config.http_port: logging.info("Starting web server") run_simple('localhost', Config.http_port, httpApp, use_reloader=True, extra_files=["static/main.css", "templates/index.html"]) logging.info("Starting main loop") try: while True: message = can_buffer.get_message() if message is not None: on_can_message(mqtt_client, message) except KeyboardInterrupt: bus.shutdown() notifier.stop() mqtt_client.loop_stop() mqtt_client.disconnect() return