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)
