def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # Set Background Image self.image = qTG.QImage("resources/background_day.jpg") self.palette = qTG.QPalette() self.palette.setBrush(qTG.QPalette.Window, qTG.QBrush(self.image)) self.setPalette(self.palette) # Set window size self.resize(800, 480) # GUI Layout Base Layer self.grid_layout_widget = qTW.QWidget(self) self.grid_layout_widget.setGeometry(0, 0, 800, 480) grid_layout = qTW.QGridLayout(self.grid_layout_widget) grid_layout.setContentsMargins(0, 0, 0, 0) vertical_center = qTW.QVBoxLayout() vertical_center.setSpacing(0) # Speedometer Value self.speed_value = qTW.QLabel(self.grid_layout_widget) self.speed_value.setObjectName("speed_value") self.speed_value.setText("0") self.speed_value.setAlignment(Qt.AlignBottom | Qt.AlignHCenter) self.speed_value.setMargin(-31) self.speed_value.setMaximumHeight(160) vertical_center.addWidget(self.speed_value) # Speedometer Label self.speed_label = qTW.QLabel(self.grid_layout_widget) self.speed_label.setObjectName("speed_label") self.speed_label.setText("MPH") self.speed_label.setAlignment(Qt.AlignHCenter | Qt.AlignTop) self.speed_label.setMargin(-10) self.speed_label.setIndent(-1) self.speed_label.setMaximumHeight(75) vertical_center.addWidget(self.speed_label) warnings_hbox = qTW.QHBoxLayout() # First Warning Spacer self.spacer = qTW.QLabel(self.grid_layout_widget) self.spacer.setAlignment(Qt.AlignRight | Qt.AlignTop) self.spacer_pix = qTG.QPixmap("resources/empty.png") self.spacer.setPixmap(self.spacer_pix) self.spacer.setScaledContents(True) self.spacer.setFixedSize(60, 60) warnings_hbox.addWidget(self.spacer) # Battery Warning self.battery = qTW.QLabel(self.grid_layout_widget) self.battery.setObjectName("battery") self.battery.setText("Battery") self.battery.setAlignment(Qt.AlignRight | Qt.AlignTop) self.battery_active_pix = qTG.QPixmap("resources/battery.png") self.battery_inactive_pix = qTG.QPixmap("resources/empty.png") self.battery.setPixmap(self.battery_inactive_pix) self.battery.setScaledContents(True) self.battery.setFixedSize(50, 50) warnings_hbox.addWidget(self.battery) # Check Engine Light self.check_engine = qTW.QLabel(self.grid_layout_widget) self.check_engine.setObjectName("check_engine") self.check_engine.setText("Check Engine") self.check_engine.setAlignment(Qt.AlignHCenter | Qt.AlignTop) self.cel_active_pix = qTG.QPixmap("resources/cel.png") self.cel_inactive_pix = qTG.QPixmap("resources/empty.png") self.check_engine.setPixmap(self.cel_inactive_pix) self.check_engine.setScaledContents(True) self.check_engine.setFixedSize(50, 50) warnings_hbox.addWidget(self.check_engine) # Airbag Warning self.airbag = qTW.QLabel(self.grid_layout_widget) self.airbag.setObjectName("airbag") self.airbag.setText("Airbag") self.airbag.setAlignment(Qt.AlignLeft | Qt.AlignTop) self.airbag_active_pix = qTG.QPixmap("resources/airbag.png") self.airbag_inactive_pix = qTG.QPixmap("resources/empty.png") self.airbag.setPixmap(self.airbag_inactive_pix) self.airbag.setScaledContents(True) self.airbag.setFixedSize(50, 50) warnings_hbox.addWidget(self.airbag) # Second Spacer warnings_hbox.addWidget(self.spacer) vertical_center.addLayout(warnings_hbox) center_bottom = qTW.QHBoxLayout() center_bottom.setSpacing(0) vertical_center.addLayout(center_bottom) # Clock self.clock = qTW.QLabel(self.grid_layout_widget) self.clock.setObjectName("clock") self.clock.setAlignment(Qt.AlignBottom | Qt.AlignHCenter) self.clock.setMargin(10) center_bottom.addWidget(self.clock) grid_layout.addLayout(vertical_center, 0, 1, 1, 1) vertical_left = qTW.QVBoxLayout() vertical_left.setSpacing(0) vertical_left.setObjectName("verticalLeft") left_top = qTW.QHBoxLayout() left_top.setSpacing(0) left_top.setObjectName("leftTop") v_left_top = qTW.QVBoxLayout() v_left_top.setObjectName("v_left_top") # Left Turn Signal self.left_turn = qTW.QLabel(self.grid_layout_widget) self.left_turn.setObjectName("left_turn") self.left_active_pix = qTG.QPixmap("resources/left.png") self.left_inactive_pix = qTG.QPixmap("resources/left_inactive.png") self.left_turn.setPixmap(self.left_inactive_pix) self.left_turn.setScaledContents(True) self.left_turn.setFixedSize(100, 100) v_left_top.addWidget(self.left_turn) # Fuel Gauge (to be implemented later) self.fuel = qTW.QLabel(self.grid_layout_widget) self.fuel.setObjectName("fuel") # self.fuel.setText("Fuel Gauge") self.fuel.setAlignment(Qt.AlignBottom | Qt.AlignHCenter) v_left_top.addWidget(self.fuel) left_top.addLayout(v_left_top) vertical_left.addLayout(left_top) # RPM Value self.rpm_value = qTW.QLabel(self.grid_layout_widget) self.rpm_value.setObjectName("rpm_value") self.rpm_value.setText("0") self.rpm_value.setAlignment(Qt.AlignBottom | Qt.AlignHCenter) self.rpm_value.setMargin(-10) vertical_left.addWidget(self.rpm_value) # RPM Label self.rpm_label = qTW.QLabel(self.grid_layout_widget) self.rpm_label.setObjectName("rpm_label") self.rpm_label.setText("RPM") self.rpm_label.setAlignment(Qt.AlignRight | Qt.AlignTop) self.rpm_label.setMargin(0) vertical_left.addWidget(self.rpm_label) left_bottom = qTW.QHBoxLayout() left_bottom.setSpacing(0) left_bottom.setObjectName("leftBottom") # Settings Button self.settings = qTW.QPushButton(self.grid_layout_widget) self.settings.setObjectName("pushButton") settings_icon = qTG.QIcon("resources/settings.png") self.settings.setFlat(True) # Make button transparent self.settings.setFixedSize(150, 100) self.settings.setIcon(settings_icon) self.settings.setIconSize(QSize(50, 50)) left_bottom.addWidget(self.settings) vertical_left.addLayout(left_bottom) grid_layout.addLayout(vertical_left, 0, 0, 1, 1) vertical_right = qTW.QVBoxLayout() vertical_right.setSpacing(0) vertical_right.setObjectName("verticalRight") right_top = qTW.QHBoxLayout() right_top.setSpacing(0) right_top.setObjectName("rightTop") v_right_top = qTW.QVBoxLayout() v_right_top.setObjectName("v_right_top") h_right_top = qTW.QHBoxLayout() h_right_top.setObjectName("horizontal_top_right") # Headlight Indicators self.headlights = qTW.QLabel(self.grid_layout_widget) self.headlights.setObjectName("headlights") self.headlights.setAlignment(Qt.AlignLeft | Qt.AlignTop) self.headlights_low_pix = qTG.QPixmap("resources/low-beam.png") self.headlights_high_pix = qTG.QPixmap("resources/high-beam_blue.png") self.headlights_inactive_pix = qTG.QPixmap("resources/empty.png") self.headlights.setPixmap(self.headlights_inactive_pix) self.headlights.setScaledContents(True) self.headlights.setFixedSize(50, 50) h_right_top.addWidget(self.headlights) # Right Turn Signal self.right_turn = qTW.QLabel(self.grid_layout_widget) self.right_turn.setObjectName("right_turn") self.right_turn.setAlignment(Qt.AlignRight | Qt.AlignTrailing | Qt.AlignVCenter) self.right_active_pix = qTG.QPixmap("resources/right.png") self.right_inactive_pix = qTG.QPixmap("resources/right_inactive.png") self.right_turn.setPixmap(self.right_inactive_pix) self.right_turn.setScaledContents(True) self.right_turn.setFixedSize(100, 100) h_right_top.addWidget(self.right_turn) v_right_top.addLayout(h_right_top) # Oil Pressure Gauge (future implementation) self.oil = qTW.QLabel(self.grid_layout_widget) self.oil.setObjectName("oil") self.oil.setAlignment(Qt.AlignBottom | Qt.AlignHCenter) # self.oil.setText("Oil Pressure") v_right_top.addWidget(self.oil) right_top.addLayout(v_right_top) vertical_right.addLayout(right_top) # Coolant Temp self.temp_value = qTW.QLabel(self.grid_layout_widget) self.temp_value.setObjectName("temp_value") self.temp_value.setAlignment(Qt.AlignBottom | Qt.AlignHCenter) self.temp_value.setText("0°") self.temp_value.setMargin(-10) vertical_right.addWidget(self.temp_value) # Coolant Temp Label self.temp_label = qTW.QLabel(self.grid_layout_widget) self.temp_label.setObjectName("temp_label") self.temp_label.setAlignment(Qt.AlignLeft | Qt.AlignTop) self.temp_label.setText("COOLANT") self.temp_label.setMargin(0) vertical_right.addWidget(self.temp_label) right_bottom = qTW.QHBoxLayout() right_bottom.setSpacing(0) right_bottom.setObjectName("rightBottom") # Night Mode Button self.night_mode_bool = False # False for day, True for Night self.night_mode = qTW.QPushButton(self.grid_layout_widget) night_mode_icon = qTG.QIcon("resources/night_mode.png") self.night_mode.setFlat(True) # Make button transparent self.night_mode.setFixedSize(150, 100) self.night_mode.setIcon(night_mode_icon) self.night_mode.setObjectName("night_mode") self.night_mode.setIconSize(QSize(50, 50)) right_bottom.addWidget(self.night_mode) vertical_right.addLayout(right_bottom) grid_layout.addLayout(vertical_right, 0, 2, 1, 1) # Make Dashboard a frameless window self.flags = qTC.Qt.WindowFlags(qTC.Qt.FramelessWindowHint) # | qTC.Qt.WindowStaysOnTopHint) self.setWindowFlags(self.flags) # Implement the .qss stylesheet self.theme = open('theme.qss').read() self.setStyleSheet(self.theme) # Initialize connection to ELM327 device self.connection = obd.Async() # Loop until connection is found # while self.connection.status() == OBDStatus.NOT_CONNECTED: # self.connection = obd.Async() # time.sleep(3) # Wait 3 sec to try again # print('Connected!') # ELM327 found # OBD Lookup Commands rpm = obd.commands.RPM speed = obd.commands.SPEED temp = obd.commands.COOLANT_TEMP cel_status = obd.commands.STATUS # Async commands to watch and callback methods self.connection.watch(rpm, callback=self.new_rpm) self.connection.watch(speed, callback=self.new_speed) self.connection.watch(temp, callback=self.new_temp) self.connection.watch(cel_status, callback=self.new_cel_status) # Begin Scan and Display DigitalDashWindow self.connection.start() self.night_mode.clicked.connect(lambda: self.switch_day_night()) self.settings.clicked.connect(lambda: self.showSettingsDialog()) # Timer for updating clock display self.timer = qTC.QTimer(self) self.timer.timeout.connect(lambda: self.update_clock()) self.timer.start(1000) # Update once per second self.show() # Show DigitalDashWindow
def async (request): """provides an OBD *Async* connection object for obdsim""" import obd port = request.config.getoption("--port") return obd.Async(port)
'rpm': 0, 'load': 0, 'fuel_status': 0, 'fuel_level': 0, 'fuel_rate': 0, 'engine_temp': 0, 'oil_temp': 0, 'throttle_pos': 0, 'fuel_rates': 0, 'fueling_time': 0 } fuelrates = [] obdconn = obd.Async() ''' obdstatic = obd.OBD() dtc = obdstatic.query(obd.commands.GET_CURRENT_DTC) print(dtc) obdstatic.close() ''' def get_obd_data(): return obddata def get_connected(): return obdconn.status() def get_speed(data): if not data.is_null():
lcd_rows = 2 self.lcd = LCD.Adafruit_CharLCD(lcd_rs, lcd_en, lcd_d4, lcd_d5, lcd_d6, lcd_d7, lcd_columns, lcd_rows, lcd_backlight) self.lcd.set_backlight(1) threading.Thread.__init__(self) self._running = True def run(self): global rpm while True: try: self.lcd.message('%s %s' % ('RPM:\n', rpm)) time.sleep(0.25) except RuntimeError: pass if __name__ == "__main__": rpm = 0 connection = obd.Async() # asynchronous connection def new_rpm(response): global rpm rpm = response.value.magnitude connection.watch(obd.commands.RPM, callback=new_rpm) connection.start() while connection.status == obd.OBDStatus.NOT_CONNECTED: time.sleep(0.1) thread_2 = lcd_thread() thread_2.start() thread_1 = led_thread() thread_1.start()
def configobd(self): try: self.connection = obd.Async(self.obd_port) except: logging.critical('No OBD found on {0}'.format(self.obd_port))
obd_json['fuel'] = f.value.magnitude def callback_maf(m): obd_json['maf'] = m.value.magnitude def callback_load(l): obd_json['load'] = l.value.magnitude def callback_temp(t): obd_json['temp'] = t.value.magnitude connection = obd.Async(cfg.obdport) connection.watch(obd.commands.RPM, callback=callback_rpm) connection.watch(obd.commands.SPEED, callback=callback_speed) connection.watch(obd.commands.FUEL_LEVEL, callback=callback_fuel) connection.watch(obd.commands.MAF, callback=callback_maf) connection.watch(obd.commands.ENGINE_LOAD, callback=callback_load) connection.watch(obd.commands.COOLANT_TEMP, callback=callback_temp) connection.start() if not connection.is_connected(): print 'ODB connection failed!' sys.exit(1) try: while (True): pubnub.publish().channel(cfg.channel).message(obd_json).sync()
print("Sent data to broker.") client = mqtt.Client() client.on_publish = my_func client.tls_set() client.username_pw_set(username='******', password='******') client.connect("ihoria.tech", 8883) client.loop_start() sensors = [ "ENGINE_LOAD", "COOLANT_TEMP", "INTAKE_PRESSURE", "RPM", "SPEED", "INTAKE_TEMP", "MAF", "THROTTLE_POS", "FUEL_LEVEL" ] connection = obd.Async("/dev/ttyUSB0") for sensor in sensors: connection.watch(obd.commands[sensor]) connection.start() while True: data = {} response = connection.query(obd.commands["RPM"]) for sensor in sensors: response = connection.query(obd.commands[sensor]) if response.is_null(): continue
def UpdateValues(self): now = datetime.now() self.bot_date.setText(now.strftime("%H:%M:%S - %B %d, %Y")) if self.connection.is_connected(): # TODO break this up into sub-functions in another file. # == Update Current Values == # SPEED = self.connection.query(obd.commands.SPEED).value.magnitude RPM = self.connection.query(obd.commands.RPM).value.magnitude MAP = self.connection.query( obd.commands.INTAKE_PRESSURE).value.magnitude TMP = self.connection.query( obd.commands.INTAKE_TEMP).value.magnitude + 273.15 CLT_TMP = self.connection.query( obd.commands.COOLANT_TEMP).value.magnitude VOLTAGE = self.connection.query( obd.commands.ELM_VOLTAGE).value.magnitude LOAD = self.connection.query( obd.commands.ENGINE_LOAD).value.magnitude # == Speed Graph == # # Calculate average value. Make sure data is less than the average value sample size. MPH_SPEED = SPEED * 0.62137 if len(self.speed_avg_list) < self.avg_val_sample_size: self.speed_avg_list.append(MPH_SPEED) else: self.speed_avg_list.pop(0) self.speed_avg_list.append(MPH_SPEED) avg = 0 for x in range(len(self.speed_avg_list)): avg += self.speed_avg_list[x] speed_mavg = avg / len(self.speed_avg_list) # Update the graph if len(self.speed_x_time) <= self.speed_run_time: self.speed_x_time.append(len(self.speed_x_time)) self.speed_y_speed.append(MPH_SPEED) else: self.speed_y_speed.pop(0) self.speed_y_speed.append(MPH_SPEED) # == RPM Graph == # # Calculate average value. Make sure data is less than the average value sample size. if len(self.rpm_avg_list) < self.avg_val_sample_size: self.rpm_avg_list.append(RPM) else: self.rpm_avg_list.pop(0) self.rpm_avg_list.append(RPM) avg = 0 for x in range(len(self.rpm_avg_list)): avg += self.rpm_avg_list[x] rpm_mavg = avg / len(self.rpm_avg_list) # Update the graph if len(self.rpm_x_time) <= self.rpm_run_time: self.rpm_x_time.append(len(self.rpm_x_time)) self.rpm_y_rpm.append(RPM) else: self.rpm_y_rpm.pop(0) self.rpm_y_rpm.append(RPM) # == MPG Calculations & Graph == # R = 8.314 # Specific gas constant MM = 28.97 # Molecular mass of air DISP = 3.964 # Engine displacement in L VE = 0.75 # Volumetric efficency, play around with this value IMAP = (RPM * MAP) / TMP MAF = (IMAP / 120) * VE * DISP * (MM / R) MPG = (710.7 * SPEED) / (MAF * 100) # Update average value. Make sure data is less than the average value sample size - update over time. if len(self.mpg_avg_list) < self.avg_val_sample_size: self.mpg_avg_list.append(MPG) else: self.mpg_avg_list.pop(0) self.mpg_avg_list.append(MPG) avg = 0 for x in range(len(self.mpg_avg_list)): avg += self.mpg_avg_list[x] mpg_mavg = avg / len(self.mpg_avg_list) # Calculate graph changes if len(self.mpg_x_time) <= self.mpg_run_time: self.mpg_x_time.append(len(self.mpg_x_time)) self.mpg_y_mpg.append(MPG) else: self.mpg_y_mpg.pop(0) self.mpg_y_mpg.append(MPG) # == Temperature Graph == # # Calculate average value. Make sure data is less than the average value sample size. if len(self.tmp_avg_list) < self.avg_val_sample_size: self.tmp_avg_list.append(CLT_TMP) else: self.tmp_avg_list.pop(0) self.tmp_avg_list.append(CLT_TMP) avg = 0 for x in range(len(self.tmp_avg_list)): avg += self.tmp_avg_list[x] tmp_mavg = avg / len(self.tmp_avg_list) # Update the graph if len(self.tmp_x_time) <= self.tmp_run_time: self.tmp_x_time.append(len(self.tmp_x_time)) self.tmp_y_tmp.append(CLT_TMP) else: self.tmp_y_tmp.pop(0) self.tmp_y_tmp.append(CLT_TMP) # == Voltage Graph == # # Calculate average value. Make sure data is less than the average value sample size. if len(self.voltage_avg_list) < self.avg_val_sample_size: self.voltage_avg_list.append(VOLTAGE) else: self.voltage_avg_list.pop(0) self.voltage_avg_list.append(VOLTAGE) avg = 0 for x in range(len(self.voltage_avg_list)): avg += self.voltage_avg_list[x] voltage_mavg = avg / len(self.voltage_avg_list) # Update the graph if len(self.voltage_x_time) <= self.voltage_run_time: self.voltage_x_time.append(len(self.voltage_x_time)) self.voltage_y_voltage.append(VOLTAGE) else: self.voltage_y_voltage.pop(0) self.voltage_y_voltage.append(VOLTAGE) # == Load Graph == # # Calculate average value. Make sure data is less than the average value sample size. if len(self.load_avg_list) < self.avg_val_sample_size: self.load_avg_list.append(LOAD) else: self.load_avg_list.pop(0) self.load_avg_list.append(LOAD) avg = 0 for x in range(len(self.load_avg_list)): avg += self.load_avg_list[x] load_mavg = avg / len(self.load_avg_list) # Update the graph if len(self.load_x_time) <= self.load_run_time: self.load_x_time.append(len(self.load_x_time)) self.load_y_load.append(LOAD) else: self.load_y_load.pop(0) self.load_y_load.append(LOAD) # == Set Dash Values == # self.rpm_value.setText(str(round(RPM, 2))) self.spd_value.setText(str(round(MPH_SPEED, 2))) self.mpg_value.setText(str(round(MPG, 2))) self.tmp_value.setText(str(round(CLT_TMP, 2))) self.vlt_value.setText(str(round(VOLTAGE, 2))) self.lod_value.setText(str(round(LOAD, 2))) # == Set Detailed Values == # # self.speed_lmi.setText(str(round(MPH_SPEED,2))) # self.speed_lma.setText(str(round(speed_mavg,2))) # self.rpm_lmi.setText(str(round(RPM,2))) # self.rpm_lma.setText(str(round(rpm_mavg,2))) # self.mpg_lmi.setText(str(round(MPG,2))) # self.mpg_lma.setText(str(round(mpg_mavg,2))) # self.tmp_lmi.setText(str(round(CLT_TMP,2))) # self.tmp_lma.setText(str(round(tmp_mavg,2))) # self.voltage_lmi.setText(str(round(VOLTAGE,2))) # self.voltage_lma.setText(str(round(voltage_mavg,2))) # self.load_lmi.setText(str(round(LOAD,2))) # self.load_lma.setText(str(round(load_mavg,2))) # # == Update Graphs == # # self.speed_gp.setData(self.speed_x_time,self.speed_y_speed) # self.rpm_gp.setData(self.rpm_x_time, self.rpm_y_rpm) # self.mpg_gp.setData(self.mpg_x_time,self.mpg_y_mpg) # self.tmp_gp.setData(self.tmp_x_time,self.tmp_y_tmp) # self.voltage_gp.setData(self.tmp_x_time,self.voltage_y_voltage) # self.load_gp.setData(self.load_x_time,self.load_y_load) else: if self.connection.is_connected(): self.connection.watch(obd.commands.SPEED) self.connection.watch(obd.commands.RPM) self.connection.watch(obd.commands.INTAKE_PRESSURE) self.connection.watch(obd.commands.INTAKE_TEMP) self.connection.watch(obd.commands.COOLANT_TEMP) self.connection.watch(obd.commands.ENGINE_LOAD) self.connection.watch(obd.commands.ELM_VOLTAGE) self.connection.start() else: # Try reestablishing connection self.connection = obd.Async()
import obd import time async_conn = obd.Async() def new_rpm(r): return r.value def rpm_async(): async_conn.watch(obd.commands.RPM, callback=new_rpm) async_conn.start() time.sleep(5) async_conn.stop();
import pygame from pygame.locals import * import obd import csv pygame.init() #connection = obd.OBD() connect = obd.Async(fast=False) screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN) screen_w = screen.get_width() screen_h = screen.get_height() circle_y = screen_h / 2 circle1_x = screen_w * .25 circle2_x = screen_w * .5 circle3_x = screen_w * .75 circle_rad = (circle2_x - circle1_x) / 2 speed_text_x = screen_w * .25 speed_text_y = screen_h * .25 rpm_text_x = screen_w * .5 rpm_text_y = screen_h * .25 load_text_x = screen_w * .75 load_text_y = screen_h * .25 headerFont = pygame.font.SysFont("Arial", 50) digitFont = pygame.font.SysFont("Arial", 50) white = (255, 255, 255) black = (0, 0, 0) grey = (112, 128, 144) speed = 0 rpm = 0 load = 0
def __init__(self, parent=None): super(Dashboard, self).__init__(parent) ########################## # -- Global Variables -- # ########################## # TODO setup csv logging csv_logging = "none" # Possible values: none (no logging), average (total average for trip), detailed (detailed for trip) csv_file = "obd_log.csv" # Refresh rate (in seconds) for OBD queries and graph updates self.refresh_rate = 0.5 # Graph x-axis range (in seconds) mpg_x_range = 60 speed_x_range = 60 rpm_x_range = 60 tmp_x_range = 60 voltage_x_range = 60 load_x_range = 60 # Average value sample set size self.avg_val_sample_size = 2500 self.queue = Queue.Queue() # Image capture options self.IMG_SIZE = 1920, 1080 # 640,480 or 1280,720 or 1920,1080 self.CAP_API = cv2.CAP_ANY # or cv2.CAP_DSHOW, etc... self.EXPOSURE = 0 # Non-zero for fixed exposure self.CAPTURING = False # System needs to be manually activated self.DISP_SCALE = 6 # Scaling factor for display image # Image save options self.sec_per_shot = 5 self.path = os.path.join("/media/pi/EnduranceS", datetime.now().strftime("%m-%d-%y-%Hh%Mm%Ss")) self.number = 0 os.mkdir(self.path) # OBD Connection self.connection = obd.Async() ######################### # -- Window Geometry -- # ######################### self.title = 'PiDashboard' self.index = 0 self.left = 10 self.top = 10 self.width = 800 self.height = 480 self.setWindowTitle(self.title) self.setGeometry(self.left, self.top, self.width, self.height) self.setStyleSheet(""" background-color: #383838; color: rgb(230,230,230); font: "Fira Sans Light"; """) self.layout = QStackedLayout() self.setLayout(self.layout) # --- Timer --- # self.timer = QTimer() #self.timer.timeout.connect(self.UpdateValues) self.timer.timeout.connect(lambda: self.show_image( self.queue, self.vp_image, self.DISP_SCALE)) self.timer.start(int(self.refresh_rate * 1000)) self.capture_thread = threading.Thread(target=self.grab_images, args=(0, self.queue, self.CAPTURING)) self.capture_thread.start() # Thread to grab images ################### # -- Dashboard -- # ################### dash_widget = QWidget() dash_layout = QGridLayout() dash_layout.rowStretch(2) dash_widget.setLayout(dash_layout) self.layout.addWidget(dash_widget) ################ # -- Spacer -- # ################ s_widget = QWidget() s_layout = QVBoxLayout() s_layout.addStretch(40) s_widget.setLayout(s_layout) dash_layout.addWidget(s_widget, 1, 1) ############################## # -- Video Preview Widget -- # ############################## vp_widget = QWidget() vp_layout = QVBoxLayout() vp_widget.setLayout(vp_layout) vp_widget.setStyleSheet("background-color: #232323;") dash_layout.addWidget(vp_widget, 2, 1) # VP Label vp_top_label = QLabel("Video Status") vp_top_label.setFont(QFont('Fira Sans', 18)) vp_top_label.setAlignment(Qt.AlignCenter) vp_top_label.setStyleSheet("color: #FFFFFF") vp_layout.addWidget(vp_top_label) # Placeholder image self.vp_image = ImageWidget() vp_layout.addWidget(self.vp_image, alignment=Qt.AlignCenter) # Button row widget vp_br_widget = QWidget() vp_br_layout = QHBoxLayout() vp_br_widget.setLayout(vp_br_layout) vp_br_play = QPushButton("Start") vp_br_play.clicked.connect(self.startCapture) vp_br_stop = QPushButton("Stop") vp_br_stop.clicked.connect(self.stopCapture) vp_br_layout.addWidget(vp_br_play) vp_br_layout.addWidget(vp_br_stop) vp_layout.addWidget(vp_br_widget) # Storage indicator bar (can we do a text indicator, like 1.24/2.00?) vp_str_bar = QProgressBar() vp_str_bar.setRange(0, 2000) vp_str_bar.setValue(0) vp_layout.addWidget(vp_str_bar) ###################### # -- Engine Stats -- # ###################### es_widget = QWidget() es_layout = QVBoxLayout() es_widget.setLayout(es_layout) es_widget.setStyleSheet("background-color: #232323;") dash_layout.addWidget(es_widget, 2, 2) # ES Label es_label = QLabel("Engine Status") es_label.setFont(QFont('Fira Sans', 18)) es_label.setAlignment(Qt.AlignCenter) es_label.setStyleSheet( "color: #FFFFFF; padding-left: 4em; padding-right: 4em;") es_layout.addWidget(es_label) # MPG Row mpgr_widget = QWidget() mpgr_layout = QHBoxLayout() mpgr_widget.setLayout(mpgr_layout) mpg_button = QPushButton("MPG") mpg_value = QLabel() mpgr_layout.addWidget(mpg_button) mpgr_layout.addWidget(mpg_value) es_layout.addWidget(mpgr_widget) # SPD Row spdr_widget = QWidget() spdr_layout = QHBoxLayout() spdr_widget.setLayout(spdr_layout) spd_button = QPushButton("SPD") spd_value = QLabel() spdr_layout.addWidget(spd_button) spdr_layout.addWidget(spd_value) es_layout.addWidget(spdr_widget) # RPM Row rpmr_widget = QWidget() rpmr_layout = QHBoxLayout() rpmr_widget.setLayout(rpmr_layout) rpm_button = QPushButton("RPM") rpm_value = QLabel() rpmr_layout.addWidget(rpm_button) rpmr_layout.addWidget(rpm_value) es_layout.addWidget(rpmr_widget) # TMP Row tmpr_widget = QWidget() tmpr_layout = QHBoxLayout() tmpr_widget.setLayout(tmpr_layout) tmp_button = QPushButton("TMP") tmp_value = QLabel() tmpr_layout.addWidget(tmp_button) tmpr_layout.addWidget(tmp_value) es_layout.addWidget(tmpr_widget) # VLT Row vltr_widget = QWidget() vltr_layout = QHBoxLayout() vltr_widget.setLayout(vltr_layout) vlt_button = QPushButton("VLT") vlt_value = QLabel() vltr_layout.addWidget(vlt_button) vltr_layout.addWidget(vlt_value) es_layout.addWidget(vltr_widget) # LOAD Row lodr_widget = QWidget() lodr_layout = QHBoxLayout() lodr_widget.setLayout(lodr_layout) lod_button = QPushButton("LOAD") lod_value = QLabel() lodr_layout.addWidget(lod_button) lodr_layout.addWidget(lod_value) es_layout.addWidget(lodr_widget) #################### # -- Bottom Row -- # #################### bot_widget = QWidget() bot_layout = QHBoxLayout() bot_widget.setLayout(bot_layout) bot_widget.setStyleSheet("background-color: #232323") dash_layout.addWidget(bot_widget, 3, 1, 1, 2) # Left spacing bot_layout.addSpacerItem(QSpacerItem(80, 10)) # Date / time label self.bot_date = QLabel("Test") self.bot_date.setFont(QFont('Fira Sans Light', 16)) self.bot_date.setAlignment(Qt.AlignVCenter) self.bot_date.setStyleSheet("color: #009D65") now = datetime.now() self.bot_date.setText(now.strftime("%H:%M:%S - %B %d, %Y")) bot_layout.addWidget(self.bot_date) # Center spacing bot_layout.addSpacerItem(QSpacerItem(200, 10)) # Power button bot_pwr = QPushButton("Power Off") bot_pwr.clicked.connect(self.powerOff) bot_hot = QPushButton("Exit") bot_hot.clicked.connect(self.exitWindow) bot_hot.isCheckable() bot_hot.isChecked() bot_layout.addWidget(bot_pwr) bot_layout.addWidget(bot_hot)
def run(self): #time.sleep(inECUdelay)# Adding a delay here may (also) be detrimental #ktb2 maybe add a try here to handle the crashes? global connection ports = obd.scan_serial() print ports # DEBUG: Set debug logging so we can see everything that is happening. obd.logger.setLevel(obd.logging.DEBUG) # (weakly) Validate elmDevice has been attached to kernel #usb fail lately, BUT this is not is ktb-1 try: os.stat(config.elmDev) except: config.elmDev = config.elmAlt #The emu is slow anyway, may as well make it stable - Oh... that and BT sucks. I've implemented stack on pcie. Sux. inECUdelay = 0.75 #elm327 bluetooths need about 1 sec, so with the lib delay of 0.25 we're more stable here # Connect to the ECU. try: connection = obd.Async(config.elmDev, 115200, "3", fast=False) except: print "INFO: 404 - Bluetooth or USB may not be connected?" #since splash doesn't come up, it will be handy to at least show the IPaddr for debug cmdStatus, config.piWlan = commands.getstatusoutput( "ifconfig wlan0 | grep 'inet ' | awk '{print $2}'") os.system("echo IP ADDRESS is %s" % (config.piWlan)) config.tapCount = 404 sys.exit() # Watch everything we care about. ## what happens of we "Care" too much? M-VCI even warns 5 param... ktb3 to test reduced list pls ### actually ktb3 I want to make them layers QOS type metrics, with rpm at 1:1 pull and temp at 1:3 runs etc ### to see if we can read a bit faster for certain values?? ### Gear seletion, ATF Temp etc worked with techstream and M-VCI cable / j2534 i ### Wonder if I'll need to get into this? ****https://github.com/keenanlaws/Python-J2534-Interface/blob/master/J2534.py ##FAILS/crashes ktb ## connection.watch(obd.commands[0x02][0xB6], callback=self.new_intake_temp) #try running for atf temp? #ktb1 these will need wrapped in try/catch statments ##bluetooth elm327 failure to read comes back "dimensionless" ##Also of intersting note, when the connection dies, last value returns and logs endlessly ##There is also an issue that calling DTCs with a tap event currently crashes the routines ktb3 connection.watch(obd.commands.RPM, callback=self.new_rpm) connection.watch(obd.commands.MAF, callback=self.new_MAF) connection.watch(obd.commands.INTAKE_TEMP, callback=self.new_intake_temp) connection.watch(obd.commands.SPEED, callback=self.new_speed) connection.watch(obd.commands.THROTTLE_POS, callback=self.new_throttle_position) connection.watch(obd.commands.ENGINE_LOAD, callback=self.new_engine_load) connection.watch(obd.commands[0x01][0x05], callback=self.new_coolant_temp) #connection.watch(obd.commands.COOLANT_TEMP, callback=self.new_coolant_temp) #this is an expensive call but is needed for my warning icons #connection.watch(obd.commands.GET_DTC, callback=self.new_dtc) #ktb3 add a less frequent level to these get error and pending and get inc connection.watch(obd.commands[0x03][0], callback=self.new_dtc) connection.watch(obd.commands[0x07][0], callback=self.new_pending) ## ktb5 the obd library only reads mode06 in CAN protocols... ## maybe try this angle https://github.com/lukevp/Python-OBD-Scanner/blob/master/pyobd2-0.4/obd/message/sid01.py #connection.watch(obd.commands[0x01][0x01], callback=self.new_incs) if config.autoclearECU: connection.watch(obd.commands.CLEAR_DTC, callback=self.new_clearDTC) ## Hey Kids! Python classes load vars like deepMetrics here ONCE during init ## So, toggling config.deepMetrics later will not change ANYTHING... :| Beware. ## the big bad DTC squasher is one way to bring this about if config.deepMetrics: connection.watch(obd.commands.TIMING_ADVANCE, callback=self.new_timing_advance) ##no support on 2001 is300+elm327## connection.watch(obd.commands.FUEL_INJECT_TIMING, callback=self.new_fuel_inject_timing) connection.watch(obd.commands.SHORT_FUEL_TRIM_1, callback=self.new_short_fuel_trim_1) connection.watch(obd.commands.SHORT_FUEL_TRIM_2, callback=self.new_short_fuel_trim_2) #IF ecu puts out high rpms, assume its an emulator, and assume that emu should not call ltft if rpm > -1 and rpm < 9999: connection.watch(obd.commands.LONG_FUEL_TRIM_1, callback=self.new_long_fuel_trim_1) connection.watch(obd.commands.LONG_FUEL_TRIM_2, callback=self.new_long_fuel_trim_2) else: ltft1 = -2 ltft2 = -2 #Else return dummy -1 values #... connection.watch(obd.commands.O2_B1S1, callback=self.new_o2_b1s1) connection.watch(obd.commands.O2_B1S2, callback=self.new_o2_b1s2) ##no support on 2001 is300+elm327## connection.watch(obd.commands.SHORT_O2_TRIM_B1, callback=self.new_short_o2_trim_b1) ##no support on 2001 is300+elm327## connection.watch(obd.commands.SHORT_O2_TRIM_B2, callback=self.new_short_o2_trim_b2) ##no support on 2001 is300+elm327## connection.watch(obd.commands.LONG_O2_TRIM_B1, callback=self.new_long_o2_trim_b1) ##no support on 2001 is300+elm327## connection.watch(obd.commands.LONG_O2_TRIM_B2, callback=self.new_long_o2_trim_b2) ##no support on 2001 is300+elm327## connection.watch(obd.commands.FUEL_RAIL_PRESSURE_DIRECT, callback=self.new_fuel_rail_pressure_direct) ##no support on 2001 is300+elm327## connection.watch(obd.commands.FUEL_RATE, callback=self.new_fuel_rate) ##Thanks again Danny @ Ratchets And Wrenches - u rock https://youtu.be/pIJdCZgEiys #short term fuel trim percent will increase if your o2 sensor goes low (lean) #long term fuel trim percent will increase gradually as short term fuel trim percent trends #stft s/b ~+/-3%, #ltft s/b ~+/-3%, #sum of ltft + stft sb under ~+/-10% # Start the connection. connection.start() # Set the ready flag so we can boot the GUI. if config.gogoGadgetGUI: config.ecuReady = True
#!/usr/bin/python3 from obd import OBDStatus from bluetooth import * import obd, subprocess, bluetooth obdaddr = "00:1D:A5:00:01:EB" def newinfo(dat): print(dat) #bt = BluetoothSocket( RFCOMM ) #bt.connect( (obdaddr, 1) ) ## hcitool notes ## con Display active connections ## subprocess.call(['sudo', 'hcitool', 'cc', obdaddr]) subprocess.call(['sudo', 'rfcomm', 'bind', '0', obdaddr]) myobd = obd.Async() myobd.watch(obd.commands.COOLANT_TEMP, callback=newinfo) myobd.start()
import os import obd import time from obd import OBD, Async, commands, Unit, OBDStatus ports = obd.scan_serial() print("Ports avail:\t", ports) if (len(ports) > 0): print(ports[0]) with obd.Async(ports[0], 115200, None, False, 4) as connection: connection.watch(obd.commands.RPM) connection.watch(obd.commands.COOLANT_TEMP) connection.watch(obd.commands.ENGINE_LOAD) connection.watch(obd.commands.LONG_FUEL_TRIM_1) connection.watch(obd.commands.ELM_VERSION) connection.watch(obd.commands.ELM_VOLTAGE) connection.start() with open('testtest.csv', 'a') as file: ecua = connection.query(obd.commands.COOLANT_TEMP) ecub = connection.query(obd.commands.RPM) file.write('\n%s,%s' % (ecua, ecub)) #d = integer, f=float, s=string, b=boolean/binary #print("ELM Version: ", connection.query(obd.commands.ELM_VERSION)) #print("ELM Voltage: ", connection.query(obd.commands.ELM_VOLTAGE)) #print("ECU - Coolant Temp: ", connection.query(obd.commands.COOLANT_TEMP)) #print("ECU - RPM: ", connection.query(obd.commands.RPM)) # non-blocking, returns immediately #print("ECU - Engine Load: ", connection.query(obd.commands.ENGINE_LOAD)) #print("ECU - Long Fuel Trim: ", connection.query(obd.commands.LONG_FUEL_TRIM_1))
def __init__(self, logger): self.connection = obd.Async() self.log = Log() self.logger = logger self.counter = 0
from time import sleep from threading import Thread from math import ceil import wx import obd import meter_Speed import meter_RPM import meter_Fuel import meter_Temp #DisplaySize = wx.GetDisplaySize() ''' Commented for testing''' # Init obd_connection = obd.Async("\.\COM4") # Callback is called when data is received obd_connection.watch(obd.commands.RPM) obd_connection.watch(obd.commands.SPEED) obd_connection.watch(obd.commands.GET_DTC) obd_connection.watch(obd.commands.DISTANCE_W_MIL) obd_connection.watch(obd.commands.COOLANT_TEMP) #obd_connection.watch(obd.commands[1][166]) '''''' class MainWindow(wx.Frame): def __init__(self, parent, title): wx.Frame.__init__(self, parent, title=title, size=wx.GetDisplaySize()) MainPanel = wx.Panel(self, size=self.GetSize())
#Prints all commands supported by the car. #For working in interactive mode. #obd.print_commands() # wait for the connection to be established and car ignition to be turned on while not connection.status() == obd.OBDStatus.CAR_CONNECTED: print( "Waiting for ignition to start. Check will be performed again in 1 second" ) print(connection.status()) time.sleep(2) # First we check and create a list of supported sub set of commands for the connected vehicle supported_commands_list = [] connection.close() #Close the sync call connection = obd.Async() # same constructor as 'obd.OBD()' for command_list in obd.commands.modes: for cmd in command_list: if cmd is None: continue # this command is reserved elif (cmd.mode >= 1) and (cmd.mode <= 9): #print(cmd.name) if connection.supports(obd.commands[cmd.name]): supported_commands_list.append(cmd.name) connection.watch(obd.commands[cmd.name]) print(supported_commands_list) #obdVals = {} #connection.watch(obd.commands["RPM"]) #connection.watch(obd.commands["FUEL_STATUS"])
#tryAgain = True #while tryAgain: # try: # connection = obd.Async(fast=False, timeout=30) # tryAgain = False # except: # time.sleep(1) # if connection couldn't be established, wait a second #while True: # if connection.status() == OBDStatus.CAR_CONNECTED: # break # connect to ELM327 OBD-II interface chip while True: try: connection = obd.Async(fast=False,timeout=30) if connection.status() == OBDStatus.CAR_CONNECTED: break except: # this code runs if the connection fails in some way print("Connection failed. Trying again ...") # this is for the log file # this is the screen output draw.rectangle((0, 0, oled.width, oled.height * 2), outline=0, fill=0) draw.text((0,0), "Connection", font=font, fill=255) draw.text((0,18), "failed. Trying", font=font, fill=255) draw.text((0,36), "again ...", font=font, fill=255) oled.image(image) oled.show() # connection data to track connection.watch(obd.commands["SPEED"])
import obd import os os.system('clear') print("Trying to connect to CAN...") connection = obd.Async(portstr="/dev/tty.usbserial-12345678", baudrate="500000", protocol="6") # same constructor as 'obd.OBD()' print(connection.status()) connection.watch(obd.commands['RPM']) # keep track of the RPM connection.start() # start the async update loop print(connection.query(obd.commands['RPM']))
#!/usr/bin/python #from threading import Thread import obd import numpy as np # Globals global connection ports = obd.scan_serial() print ports # DEBUG: Set debug logging so we can see everything that is happening. obd.logger.setLevel(obd.logging.DEBUG) # Connect to the ECU. connection = obd.Async("/dev/ttyUSB0", 115200, "3", fast=False) ##or #connection = obd.Async("/dev/rfcomm0", 115200, "3", fast=False) ##where you ran a command this boot `sudo rfcomm bind 0 00:1D:A5:02:09:48` ##(sample mac address of paired bluetootctrl elm327 device) # Start the connection. connection.start() def run(self): global connection ports = obd.scan_serial() print ports
import obd #import speech_recognition as sr obd.logger.setLevel(obd.logging.DEBUG) import time import os #from gtts import gTTS #from pygame import mixer #from gtest import ignition #from mpu_gps_logging import gps_data connection = obd.Async(fast=False) cr = 0 cs = 0 filetime = time.strftime("%Y%m%d-%H%M%S") f = open("rawtxtday" + filetime + ".txt", "w") """ def getRPM_voice(): connection = obd.OBD() response = connection.query(obd.commands.RPM) ignition(str(response.value.magnitude)) """ # a callback that prints every new value to the console def new_rpm(r): print("RPM : " + str(r.value.magnitude)) f.write(str(r.value.magnitude) + ", ")
import os import obd import time from obd import OBD, Async, commands, Unit, OBDStatus connection = obd.Async("/dev/ttyAMA0", 115200, None, False, 4) connection.watch(obd.commands.RPM) connection.watch(obd.commands.COOLANT_TEMP) connection.watch(obd.commands.ENGINE_LOAD) connection.watch(obd.commands.LONG_FUEL_TRIM_1) connection.watch(obd.commands.ELM_VERSION) connection.watch(obd.commands.ELM_VOLTAGE) connection.start() print("ELM Version: ", connection.query(obd.commands.ELM_VERSION)) print("ELM Voltage: ", connection.query(obd.commands.ELM_VOLTAGE)) print("ECU - Coolant Temp: ", connection.query(obd.commands.COOLANT_TEMP)) print("ECU - RPM: ", connection.query(obd.commands.RPM)) # non-blocking, returns immediately print("ECU - Engine Load: ", connection.query(obd.commands.ENGINE_LOAD)) print("ECU - Long Fuel Trim: ", connection.query(obd.commands.LONG_FUEL_TRIM_1)) time.sleep(60) connection.stop()
window, new_speed, new_rpm, new_coolant_temp, new_engine_load, new_intake_temp, new_throttle_pos, new_timing_adv, conn_lbl, ) try: # Start async connection to OBD adapter # connection = obd.Async(baudrate=9600) connection = obd.Async() # Set up codes to watch with callbacks connection.watch(obd.commands.SPEED, callback=new_speed) connection.watch(obd.commands.RPM, callback=new_rpm) connection.watch(obd.commands.COOLANT_TEMP, callback=new_coolant_temp) connection.watch(obd.commands.ENGINE_LOAD, callback=new_engine_load) connection.watch(obd.commands.INTAKE_TEMP, callback=new_intake_temp) connection.watch(obd.commands.THROTTLE_POS, callback=new_throttle_pos) connection.watch(obd.commands.TIMING_ADVANCE, callback=new_timing_adv) # connection.watch(obd.commands.ELM_VOLTAGE, callback=new_obd_voltage) # connection.watch(obd.commands.FUEL_STATUS, callback=new_fuel_status) # Start monitoring connection.start() conn_lbl.configure(text=connection.status())
#checking git hahahaahah #poda paani import obd import time connection = obd.Async(baudrate=38400, fast=False) # create an asynchronous connection # will continuously print new RPM values def new_value1(response1): print(response1) # keep track of the car's RPM connection.watch(obd.commands.ELM_VOLTAGE, callback=new_value1) def new_value2(response2): print(response2) # keep track of the car's RPM connection.watch(obd.commands.RPM, callback=new_value2) def new_value3(response3): print(response3)