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
