def test_init(self):
with mock.patch("usb.core.find"), mock.patch(
"threading.Thread.start") as m_start:
self.kpro = Kpro()
assert self.kpro.status is True
# update method in a thread has been tried to start
assert m_start.called is True
def setup_method(self):
# we are not unit testing USB features so it may raise a
# `usb.core.NoBackendError` e.g. on Docker
with mock.patch("devices.kpro.kpro.Kpro.__init__") as m___init__:
m___init__.return_value = None
self.kpro = Kpro()
self.kpro.data0 = [None for _ in range(38)]
self.kpro.data1 = [None for _ in range(6)]
self.kpro.data3 = [None for _ in range(82)]
self.kpro.data4 = [None for _ in range(18)]
def test_init_no_kpro_connected(self):
with mock.patch("usb.core.find") as m_find, mock.patch(
"threading.Thread.start") as m_start:
m_find.return_value = None
self.kpro = Kpro()
assert self.kpro.status is False
assert self.kpro.version is None
# update method in a thread has not been tried to start
assert m_start.called is False
# been trying to find the two kpro versions per 10 times, so 20 times calling usb find method
assert m_find.call_count == 20
def test_init_with_all_kpro_versions(self, kpro_version, kpro_vendor_id,
kpro_product_id):
def found_device(idVendor, idProduct):
if idVendor == kpro_vendor_id and idProduct == kpro_product_id:
return MagicMock()
else:
return None
with mock.patch("usb.core.find") as m_find, mock.patch(
"threading.Thread.start") as m_start:
m_find.side_effect = found_device
self.kpro = Kpro()
assert self.kpro.status is True
# update method in a thread has been tried to start
assert m_start.called is True
assert self.kpro.version == kpro_version
def setUp(self):
# we are not unit testing USB features so it may raise a
# `usb.core.NoBackendError` e.g. on Docker
with mock.patch('devices.kpro.kpro.Kpro.__init__') as m___init__:
m___init__.return_value = None
self.kpro = Kpro()
self.kpro.data0 = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0
]
self.kpro.data1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
self.kpro.data3 = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
def setUp(self):
# we are not unit testing USB features so it may raise a
# `usb.core.NoBackendError` e.g. on Docker
with mock.patch('devices.kpro.kpro.Kpro.__init__') as m___init__:
m___init__.return_value = None
self.kpro = Kpro()
self.kpro.data0 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
self.kpro.data1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
self.kpro.data3 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
class Backend:
def __init__(self):
self._load_user_preferences()
self._init_resources()
self._init_websocket()
def stop(self):
self.websocket.stop()
def _init_websocket(self):
self.websocket = Websocket(self)
def _init_resources(self):
self.time = Time()
self.odo = Odometer()
self.kpro = Kpro()
def _load_user_preferences(self):
"""
In order to read only once from the setup file
we will load in memory some user preferences that we are gonna use later on.
"""
self.setup_file = SetupFile()
self.style = Style(
self.setup_file.json.get("style").get("tpsLowerThreshold"),
self.setup_file.json.get("style").get("tpsUpperThreshold"),
self.setup_file.json.get("style").get("elapsedSeconds"),
)
self.iat_unit = self.setup_file.json.get("iat",
{}).get("unit", "celsius")
self.ect_unit = self.setup_file.json.get("ect",
{}).get("unit", "celsius")
self.vss_unit = self.setup_file.json.get("vss", {}).get("unit", "kmh")
self.o2_unit = self.setup_file.json.get("o2", {}).get("unit", "afr")
self.odo_unit = self.setup_file.json.get("odo", {}).get("unit", "km")
self.map_unit = self.setup_file.json.get("map", {}).get("unit", "bar")
self.an0_unit = self.setup_file.json.get("an0",
{}).get("unit", "volts")
self.an1_unit = self.setup_file.json.get("an1",
{}).get("unit", "volts")
self.an2_unit = self.setup_file.json.get("an2",
{}).get("unit", "volts")
self.an3_unit = self.setup_file.json.get("an3",
{}).get("unit", "volts")
self.an4_unit = self.setup_file.json.get("an4",
{}).get("unit", "volts")
self.an5_unit = self.setup_file.json.get("an5",
{}).get("unit", "volts")
self.an6_unit = self.setup_file.json.get("an6",
{}).get("unit", "volts")
self.an7_unit = self.setup_file.json.get("an7",
{}).get("unit", "volts")
self.an0_formula = self.setup_file.get_formula("an0")
self.an1_formula = self.setup_file.get_formula("an1")
self.an2_formula = self.setup_file.get_formula("an2")
self.an3_formula = self.setup_file.get_formula("an3")
self.an4_formula = self.setup_file.get_formula("an4")
self.an5_formula = self.setup_file.get_formula("an5")
self.an6_formula = self.setup_file.get_formula("an6")
self.an7_formula = self.setup_file.get_formula("an7")
def update(self):
""" load the websocket with updated info """
if not self.kpro.status: # if kpro is down try to reconnect
self.kpro.find_and_connect()
self.odo.save(self.kpro.vss["kmh"])
self.style.update(self.kpro.tps)
return {
"bat": self.kpro.bat,
"gear": self.kpro.gear,
"iat": self.kpro.iat[self.iat_unit],
"tps": self.kpro.tps,
"ect": self.kpro.ect[self.ect_unit],
"rpm": self.kpro.rpm,
"vss": self.kpro.vss[self.vss_unit],
"o2": self.kpro.o2[self.o2_unit],
"cam": self.kpro.cam,
"mil": self.kpro.mil,
"fan": self.kpro.fanc,
"bksw": self.kpro.bksw,
"flr": self.kpro.flr,
"eth": self.kpro.eth,
"scs": self.kpro.scs,
"fmw": self.kpro.firmware,
"map": self.kpro.map[self.map_unit],
"an0": self.an0_formula(self.kpro.analog_input(0))[self.an0_unit],
"an1": self.an1_formula(self.kpro.analog_input(1))[self.an1_unit],
"an2": self.an2_formula(self.kpro.analog_input(2))[self.an2_unit],
"an3": self.an3_formula(self.kpro.analog_input(3))[self.an3_unit],
"an4": self.an4_formula(self.kpro.analog_input(4))[self.an4_unit],
"an5": self.an5_formula(self.kpro.analog_input(5))[self.an5_unit],
"an6": self.an6_formula(self.kpro.analog_input(6))[self.an6_unit],
"an7": self.an7_formula(self.kpro.analog_input(7))[self.an7_unit],
"time": self.time.get_time(),
"odo": self.odo.get_mileage()[self.odo_unit],
"style": self.style.status,
"ver": __version__,
}
def setup(self):
"""Return the current setup"""
return self.setup_file.load_setup()
def save(self, new_setup):
"""Save a new setup"""
self.setup_file.save_setup(new_setup)
self.setup_file.rotate_screen(new_setup["screen"]["rotate"])
self._load_user_preferences() # refresh the backend too
def reset(self):
"""Reset to the default setup"""
self.setup_file.reset_setup()
self._load_user_preferences() # refresh the backend too
def save(new_setup):
setup_file.save_setup(new_setup)
setup_file.rotate_screen(new_setup['screen']['rotate'])
while True:
try:
run()
break
except Exception:
continue
time = Time()
setup_file = SetupFile()
odo = Odometer()
kpro = Kpro()
iat_unit = setup_file.json.get('iat', {}).get('unit', 'celsius')
ect_unit = setup_file.json.get('ect', {}).get('unit', 'celsius')
vss_unit = setup_file.json.get('vss', {}).get('unit', 'kmh')
o2_unit = setup_file.json.get('o2', {}).get('unit', 'afr')
odo_unit = setup_file.json.get('odo', {}).get('unit', 'km')
map_unit = setup_file.json.get('map', {}).get('unit', 'bar')
an0_unit = setup_file.json.get('an0', {}).get('unit', 'volts')
an1_unit = setup_file.json.get('an1', {}).get('unit', 'volts')
an2_unit = setup_file.json.get('an2', {}).get('unit', 'volts')
an3_unit = setup_file.json.get('an3', {}).get('unit', 'volts')
an4_unit = setup_file.json.get('an4', {}).get('unit', 'volts')
an5_unit = setup_file.json.get('an5', {}).get('unit', 'volts')
an6_unit = setup_file.json.get('an6', {}).get('unit', 'volts')
an7_unit = setup_file.json.get('an7', {}).get('unit', 'volts')
class TestKpro(TestCase):
def setUp(self):
# we are not unit testing USB features so it may raise a
# `usb.core.NoBackendError` e.g. on Docker
with mock.patch('devices.kpro.kpro.Kpro.__init__') as m___init__:
m___init__.return_value = None
self.kpro = Kpro()
self.kpro.data0 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
self.kpro.data1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
self.kpro.data3 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
def test_battery_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data1[4] = 123
self.assertEqual(self.kpro.bat(), 12.3)
def test_rpm_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[2] = 100
self.kpro.data0[3] = 100
self.assertEqual(self.kpro.rpm(), 6425)
def test_tps_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[5] = 100
self.assertEqual(self.kpro.tps(), 37)
def test_o2_v4_valid(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[16] = 0
self.kpro.data0[17] = 128
self.assertEqual(self.kpro.o2()['afr'], 14.7)
self.assertEqual(self.kpro.o2()['lambda'], 1)
def test_o2_v23_valid(self):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[18] = 0
self.kpro.data0[19] = 128
self.assertEqual(self.kpro.o2()['afr'], 14.7)
self.assertEqual(self.kpro.o2()['lambda'], 1)
def test_o2_v4_division_by_zero(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[18] = 0
self.kpro.data0[19] = 0
self.assertEqual(self.kpro.o2()['afr'], 0)
self.assertEqual(self.kpro.o2()['lambda'], 0)
def test_vss_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[4] = 100
self.assertEqual(self.kpro.vss()['kmh'], 100)
self.assertEqual(self.kpro.vss()['mph'], 62)
def test_vss_v23(self):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[6] = 100
self.assertEqual(self.kpro.vss()['kmh'], 100)
self.assertEqual(self.kpro.vss()['mph'], 62)
def test_ect_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data1[2] = 31
self.assertEqual(self.kpro.ect()['celsius'], 90)
self.assertEqual(self.kpro.ect()['fahrenheit'], 194)
def test_ect_v23(self):
self.kpro.version = constants.KPRO23_ID
self.kpro.data1[4] = 31
self.assertEqual(self.kpro.ect()['celsius'], 90)
self.assertEqual(self.kpro.ect()['fahrenheit'], 194)
def test_iat_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data1[3] = 31
self.assertEqual(self.kpro.iat()['celsius'], 90)
self.assertEqual(self.kpro.iat()['fahrenheit'], 194)
def test_iat_v23(self):
self.kpro.version = constants.KPRO23_ID
self.kpro.data1[5] = 31
self.assertEqual(self.kpro.iat()['celsius'], 90)
self.assertEqual(self.kpro.iat()['fahrenheit'], 194)
def test_map_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[6] = 100
self.assertEqual(self.kpro.map()['bar'], 1)
self.assertEqual(self.kpro.map()['mbar'], 1000)
self.assertEqual(self.kpro.map()['psi'], 14.503773773)
def test_map_v23(self):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[8] = 100
self.assertEqual(self.kpro.map()['bar'], 1)
self.assertEqual(self.kpro.map()['mbar'], 1000)
self.assertEqual(self.kpro.map()['psi'], 14.503773773)
def test_analog_input_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data3[66] = 52
self.kpro.data3[67] = 3
self.kpro.data3[68] = 52
self.kpro.data3[69] = 3
self.kpro.data3[70] = 52
self.kpro.data3[71] = 3
self.kpro.data3[72] = 52
self.kpro.data3[73] = 3
self.kpro.data3[74] = 52
self.kpro.data3[75] = 3
self.kpro.data3[76] = 52
self.kpro.data3[77] = 3
self.kpro.data3[78] = 52
self.kpro.data3[79] = 3
self.kpro.data3[80] = 52
self.kpro.data3[81] = 3
self.assertEqual(self.kpro.analog_input(0), 1.0009765625)
self.assertEqual(self.kpro.analog_input(1), 1.0009765625)
self.assertEqual(self.kpro.analog_input(2), 1.0009765625)
self.assertEqual(self.kpro.analog_input(3), 1.0009765625)
self.assertEqual(self.kpro.analog_input(4), 1.0009765625)
self.assertEqual(self.kpro.analog_input(5), 1.0009765625)
self.assertEqual(self.kpro.analog_input(6), 1.0009765625)
self.assertEqual(self.kpro.analog_input(7), 1.0009765625)
# sudo python bench/test.py
from __future__ import print_function
from reprint import output
from devices.kpro.kpro import Kpro
kpro = Kpro()
with output(output_type="dict", initial_len=1, interval=0) as output_list:
while True:
output_list["ETH"] = str(kpro.eth())
output_list["FLT"] = str(kpro.flt())
output_list["BAT"] = str(kpro.bat())
output_list["CAM"] = str(kpro.cam())
output_list["O2"] = str(kpro.o2())
output_list["IAT"] = str(kpro.iat())
output_list["RPM"] = str(kpro.rpm())
output_list["TPS"] = str(kpro.tps())
output_list["VSS"] = str(kpro.vss())
output_list["ECT"] = str(kpro.ect())
output_list["GEAR"] = str(kpro.gear())
output_list["EPS"] = str(kpro.eps())
output_list["SCS"] = str(kpro.scs())
output_list["RVSLCK"] = str(kpro.rvslck())
output_list["BKSW"] = str(kpro.bksw())
output_list["ACSW"] = str(kpro.acsw())
output_list["ACCL"] = str(kpro.accl())
output_list["FLR"] = str(kpro.flr())
output_list["FANC"] = str(kpro.fanc())
output_list["MAP"] = str(kpro.map())
output_list["AN0"] = str(kpro.analog_input(0))
while True:
try:
run()
break
except Exception:
continue
time = Time()
setup_file = SetupFile()
odo = Odometer()
style = Style(
setup_file.json.get("style").get("tpsLowerThreshold"),
setup_file.json.get("style").get("tpsUpperThreshold"),
setup_file.json.get("style").get("elapsedSeconds"),
)
kpro = Kpro()
iat_unit = setup_file.json.get("iat", {}).get("unit", "celsius")
ect_unit = setup_file.json.get("ect", {}).get("unit", "celsius")
vss_unit = setup_file.json.get("vss", {}).get("unit", "kmh")
o2_unit = setup_file.json.get("o2", {}).get("unit", "afr")
odo_unit = setup_file.json.get("odo", {}).get("unit", "km")
map_unit = setup_file.json.get("map", {}).get("unit", "bar")
an0_unit = setup_file.json.get("an0", {}).get("unit", "volts")
an1_unit = setup_file.json.get("an1", {}).get("unit", "volts")
an2_unit = setup_file.json.get("an2", {}).get("unit", "volts")
an3_unit = setup_file.json.get("an3", {}).get("unit", "volts")
an4_unit = setup_file.json.get("an4", {}).get("unit", "volts")
an5_unit = setup_file.json.get("an5", {}).get("unit", "volts")
an6_unit = setup_file.json.get("an6", {}).get("unit", "volts")
an7_unit = setup_file.json.get("an7", {}).get("unit", "volts")
class TestKpro:
temp_sensor_argvalues = ((51, 69, 156), (40, 80, 175), (31, 91, 195))
def setup_method(self):
# we are not unit testing USB features so it may raise a
# `usb.core.NoBackendError` e.g. on Docker
with mock.patch("devices.kpro.kpro.Kpro.__init__") as m___init__:
m___init__.return_value = None
self.kpro = Kpro()
self.kpro.data0 = [None for _ in range(38)]
self.kpro.data1 = [None for _ in range(7)]
self.kpro.data3 = [None for _ in range(100)]
self.kpro.data4 = [None for _ in range(18)]
self.kpro.data5 = [None for _ in range(20)]
def test_init(self):
with mock.patch("usb.core.find"), mock.patch(
"threading.Thread.start") as m_start:
self.kpro = Kpro()
assert self.kpro.status is True
# update method in a thread has been tried to start
assert m_start.called is True
@pytest.mark.parametrize(
"kpro_version, kpro_vendor_id, kpro_product_id",
(
(
constants.KPRO23_ID,
constants.KPRO23_ID_VENDOR,
constants.KPRO23_ID_PRODUCT,
),
(constants.KPRO4_ID, constants.KPRO4_ID_VENDOR,
constants.KPRO4_ID_PRODUCT),
),
)
def test_init_with_all_kpro_versions(self, kpro_version, kpro_vendor_id,
kpro_product_id):
def found_device(idVendor, idProduct):
if idVendor == kpro_vendor_id and idProduct == kpro_product_id:
return MagicMock()
else:
return None
with mock.patch("usb.core.find") as m_find, mock.patch(
"threading.Thread.start") as m_start:
m_find.side_effect = found_device
self.kpro = Kpro()
assert self.kpro.status is True
# update method in a thread has been tried to start
assert m_start.called is True
assert self.kpro.version == kpro_version
def test_init_no_kpro_connected(self):
with mock.patch("usb.core.find") as m_find, mock.patch(
"threading.Thread.start") as m_start:
m_find.return_value = None
self.kpro = Kpro()
assert self.kpro.status is False
assert self.kpro.version is None
# update method in a thread has not been tried to start
assert m_start.called is False
# been trying to find the two kpro versions per 10 times, so 20 times calling usb find method
assert m_find.call_count == 20
@pytest.mark.parametrize(
"version, index, value, result",
(
(None, 0, 666, 0),
(constants.KPRO23_ID, constants.KPRO23_BAT, 123, 12.3),
(constants.KPRO4_ID, constants.KPRO4_BAT, 123, 12.3),
),
)
def test_bat(self, version, index, value, result):
self.kpro.version = version
self.kpro.data1[index] = value
assert self.kpro.bat == result
def test_eth(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data3[constants.KPRO4_ETH] = 50
assert self.kpro.eth == 50
def test_flt(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data3[constants.KPRO4_FLT] = 50
assert self.kpro.flt == {"celsius": 50, "fahrenheit": 122.0}
@pytest.mark.parametrize(
"version, index1, index2, value1, value2, result",
(
(
constants.KPRO23_ID,
constants.KPRO23_RPM1,
constants.KPRO23_RPM2,
100,
100,
6425,
),
(
constants.KPRO4_ID,
constants.KPRO4_RPM1,
constants.KPRO4_RPM2,
100,
100,
6425,
),
),
)
def test_rpm(self, version, index1, index2, value1, value2, result):
self.kpro.version = version
self.kpro.data0[index1] = value1
self.kpro.data0[index2] = value2
assert self.kpro.rpm == result
@pytest.mark.parametrize(
"version, index, value, result",
(
(constants.KPRO23_ID, constants.KPRO23_TPS, 100, 37),
(constants.KPRO4_ID, constants.KPRO4_TPS, 100, 37),
(None, constants.KPRO4_TPS, 666, 0),
),
)
def test_tps(self, version, index, value, result):
self.kpro.version = version
self.kpro.data0[index] = value
assert self.kpro.tps == result
@pytest.mark.parametrize(
"version, index1, index2, value1, value2, result_afr, result_lambda",
(
(
constants.KPRO23_ID,
constants.KPRO23_AFR1,
constants.KPRO23_AFR2,
0,
128,
14.7,
1,
),
(
constants.KPRO4_ID,
constants.KPRO4_AFR1,
constants.KPRO4_AFR2,
0,
128,
14.7,
1,
),
(
constants.KPRO4_ID,
constants.KPRO4_AFR1,
constants.KPRO4_AFR2,
0,
0,
0,
0,
),
(
None,
0,
0,
666,
666,
0,
0,
),
),
)
def test_o2(self, version, index1, index2, value1, value2, result_afr,
result_lambda):
self.kpro.version = version
self.kpro.data0[index1] = value1
self.kpro.data0[index2] = value2
assert self.kpro.o2["afr"] == result_afr
assert self.kpro.o2["lambda"] == result_lambda
@pytest.mark.parametrize(
"version, index, value, result_kmh, result_mph",
(
(None, 0, None, 0, 0),
(constants.KPRO23_ID, constants.KPRO23_VSS, 100, 100, 62),
(constants.KPRO4_ID, constants.KPRO4_VSS, 100, 100, 62),
),
)
def test_vss(self, version, index, value, result_kmh, result_mph):
self.kpro.version = version
self.kpro.data0[index] = value
assert self.kpro.vss["kmh"] == result_kmh
assert self.kpro.vss["mph"] == result_mph
@pytest.mark.parametrize(
"version, index, values",
(
(None, 0, (None, 0, 0)),
(constants.KPRO23_ID, constants.KPRO23_ECT,
temp_sensor_argvalues[0]),
(constants.KPRO23_ID, constants.KPRO23_ECT,
temp_sensor_argvalues[1]),
(constants.KPRO23_ID, constants.KPRO23_ECT,
temp_sensor_argvalues[2]),
(constants.KPRO4_ID, constants.KPRO4_ECT,
temp_sensor_argvalues[0]),
(constants.KPRO4_ID, constants.KPRO4_ECT,
temp_sensor_argvalues[1]),
(constants.KPRO4_ID, constants.KPRO4_ECT,
temp_sensor_argvalues[2]),
),
)
def test_ect(self, version, index, values):
self.kpro.version = version
self.kpro.data1[index] = values[0]
assert self.kpro.ect["celsius"] == values[1]
assert self.kpro.ect["fahrenheit"] == values[2]
@pytest.mark.parametrize(
"version, index, values",
(
(None, 0, (None, 0, 0)),
(constants.KPRO23_ID, constants.KPRO23_IAT,
temp_sensor_argvalues[0]),
(constants.KPRO23_ID, constants.KPRO23_IAT,
temp_sensor_argvalues[1]),
(constants.KPRO23_ID, constants.KPRO23_IAT,
temp_sensor_argvalues[2]),
(constants.KPRO4_ID, constants.KPRO4_IAT,
temp_sensor_argvalues[0]),
(constants.KPRO4_ID, constants.KPRO4_IAT,
temp_sensor_argvalues[1]),
(constants.KPRO4_ID, constants.KPRO4_IAT,
temp_sensor_argvalues[2]),
),
)
def test_iat(self, version, index, values):
self.kpro.version = version
self.kpro.data1[index] = values[0]
assert self.kpro.iat["celsius"] == values[1]
assert self.kpro.iat["fahrenheit"] == values[2]
@pytest.mark.parametrize(
"version, index, value, result",
(
(None, 0, 100, (0, 0, 0)),
(constants.KPRO23_ID, constants.KPRO23_MAP, 100,
(1, 1000, 14.503773773)),
(constants.KPRO4_ID, constants.KPRO4_MAP, 100,
(1, 1000, 14.503773773)),
),
)
def test_map(self, version, index, value, result):
self.kpro.version = version
self.kpro.data0[index] = value
assert self.kpro.map["bar"] == result[0]
assert self.kpro.map["mbar"] == result[1]
assert self.kpro.map["psi"] == result[2]
@pytest.mark.parametrize(
"version, index, value, result",
(
(constants.KPRO23_ID, constants.KPRO23_CAM, 100, 30.0),
(constants.KPRO4_ID, constants.KPRO4_CAM, 100, 30.0),
),
)
def test_cam(self, version, index, value, result):
self.kpro.version = version
self.kpro.data0[index] = value
assert self.kpro.cam == result
@pytest.mark.parametrize(
"version, index, value, result",
(
(constants.KPRO23_ID, constants.KPRO23_GEAR, 0, "N"),
(constants.KPRO23_ID, constants.KPRO23_GEAR, 1, 1),
(constants.KPRO4_ID, constants.KPRO4_GEAR, 0, "N"),
(constants.KPRO4_ID, constants.KPRO4_GEAR, 1, 1),
),
)
def test_gear(self, version, index, value, result):
self.kpro.version = version
self.kpro.data0[index] = value
assert self.kpro.gear == result
@pytest.mark.parametrize(
"version, index, value, result",
(
(None, 0, None, False),
(constants.KPRO23_ID, constants.KPRO23_EPS, 0, False),
(constants.KPRO23_ID, constants.KPRO23_EPS, 32, True),
(constants.KPRO4_ID, constants.KPRO4_EPS, 0, False),
(constants.KPRO4_ID, constants.KPRO4_EPS, 32, True),
),
)
def test_eps(self, version, index, value, result):
self.kpro.version = version
self.kpro.data0[index] = value
assert self.kpro.eps == result
@pytest.mark.parametrize(
"version, index, value, result",
(
(None, 0, None, False),
(constants.KPRO23_ID, constants.KPRO23_SCS, 0, False),
(constants.KPRO23_ID, constants.KPRO23_SCS, 16, True),
(constants.KPRO4_ID, constants.KPRO4_SCS, 0, False),
(constants.KPRO4_ID, constants.KPRO4_SCS, 16, True),
),
)
def test_scs(self, version, index, value, result):
self.kpro.version = version
self.kpro.data0[index] = value
assert self.kpro.scs == result
@pytest.mark.parametrize(
"version, index, value, result",
(
(None, 0, None, False),
(constants.KPRO23_ID, constants.KPRO23_RVSLCK, 0, False),
(constants.KPRO23_ID, constants.KPRO23_RVSLCK, 1, True),
(constants.KPRO4_ID, constants.KPRO4_RVSLCK, 0, False),
(constants.KPRO4_ID, constants.KPRO4_RVSLCK, 1, True),
),
)
def test_rvslck(self, version, index, value, result):
self.kpro.version = version
self.kpro.data0[index] = value
assert self.kpro.rvslck == result
@pytest.mark.parametrize(
"version, index, value, result",
(
(None, 0, None, False),
(constants.KPRO23_ID, constants.KPRO23_BKSW, 0, False),
(constants.KPRO23_ID, constants.KPRO23_BKSW, 2, True),
(constants.KPRO4_ID, constants.KPRO4_BKSW, 0, False),
(constants.KPRO4_ID, constants.KPRO4_BKSW, 2, True),
),
)
def test_bksw(self, version, index, value, result):
self.kpro.version = version
self.kpro.data0[index] = value
assert self.kpro.bksw == result
@pytest.mark.parametrize(
"version, index, value, result",
(
(constants.KPRO23_ID, constants.KPRO23_ACSW, 0, False),
(constants.KPRO23_ID, constants.KPRO23_ACSW, 4, True),
(constants.KPRO4_ID, constants.KPRO4_ACSW, 0, False),
(constants.KPRO4_ID, constants.KPRO4_ACSW, 4, True),
),
)
def test_acsw(self, version, index, value, result):
self.kpro.version = version
self.kpro.data0[index] = value
assert self.kpro.acsw == result
@pytest.mark.parametrize(
"version, index, value, result",
(
(constants.KPRO23_ID, constants.KPRO23_ACCL, 0, False),
(constants.KPRO23_ID, constants.KPRO23_ACCL, 8, True),
(constants.KPRO4_ID, constants.KPRO4_ACCL, 0, False),
(constants.KPRO4_ID, constants.KPRO4_ACCL, 8, True),
),
)
def test_accl(self, version, index, value, result):
self.kpro.version = version
self.kpro.data0[index] = value
assert self.kpro.accl == result
@pytest.mark.parametrize(
"version, index, value, result",
(
(constants.KPRO23_ID, constants.KPRO23_FLR, 0, False),
(constants.KPRO23_ID, constants.KPRO23_FLR, 64, True),
(constants.KPRO4_ID, constants.KPRO4_FLR, 0, False),
(constants.KPRO4_ID, constants.KPRO4_FLR, 64, True),
),
)
def test_flr(self, version, index, value, result):
self.kpro.version = version
self.kpro.data0[index] = value
assert self.kpro.flr == result
@pytest.mark.parametrize(
"version, index, value, result",
(
(constants.KPRO23_ID, constants.KPRO23_FANC, 0, False),
(constants.KPRO23_ID, constants.KPRO23_FANC, 128, True),
(constants.KPRO4_ID, constants.KPRO4_FANC, 0, False),
(constants.KPRO4_ID, constants.KPRO4_FANC, 128, True),
),
)
def test_fanc(self, version, index, value, result):
self.kpro.version = version
self.kpro.data0[index] = value
assert self.kpro.fanc == result
@pytest.mark.parametrize(
"version, index, value, result",
(
(None, 0, None, False),
(constants.KPRO23_ID, constants.KPRO23_IGN, 0, False),
(constants.KPRO23_ID, constants.KPRO23_IGN, 1, True),
(constants.KPRO4_ID, constants.KPRO4_IGN, 0, False),
(constants.KPRO4_ID, constants.KPRO4_IGN, 1, True),
),
)
def test_ign(self, version, index, value, result):
self.kpro.version = version
self.kpro.data4[index] = value
assert self.kpro.ign == result
@pytest.mark.parametrize(
"index1, index2, value1, value2, channel, result",
(
(constants.KPRO4_AN0_1, constants.KPRO4_AN0_2, 3, 52, 0,
1.0009765625),
(constants.KPRO4_AN1_1, constants.KPRO4_AN1_2, 3, 52, 1,
1.0009765625),
(constants.KPRO4_AN2_1, constants.KPRO4_AN2_2, 3, 52, 2,
1.0009765625),
(constants.KPRO4_AN3_1, constants.KPRO4_AN3_2, 3, 52, 3,
1.0009765625),
(constants.KPRO4_AN4_1, constants.KPRO4_AN4_2, 3, 52, 4,
1.0009765625),
(constants.KPRO4_AN5_1, constants.KPRO4_AN5_2, 3, 52, 5,
1.0009765625),
(constants.KPRO4_AN6_1, constants.KPRO4_AN6_2, 3, 52, 6,
1.0009765625),
(constants.KPRO4_AN7_1, constants.KPRO4_AN7_2, 3, 52, 7,
1.0009765625),
),
)
def test_analog_input_v4(self, index1, index2, value1, value2, channel,
result):
self.kpro.version = constants.KPRO4_ID
self.kpro.data3[index2] = value2
self.kpro.data3[index1] = value1
assert self.kpro.analog_input(channel) == result
@pytest.mark.parametrize(
"index1, index2, value1, value2, channel, result",
(
(constants.KPRO3_AN0_1, constants.KPRO3_AN0_2, 3, 52, 0,
4.00390625),
(constants.KPRO3_AN1_1, constants.KPRO3_AN1_2, 3, 52, 1,
4.00390625),
(constants.KPRO3_AN2_1, constants.KPRO3_AN2_2, 3, 52, 2,
4.00390625),
(constants.KPRO3_AN3_1, constants.KPRO3_AN3_2, 3, 52, 3,
4.00390625),
(constants.KPRO3_AN4_1, constants.KPRO3_AN4_2, 3, 52, 4,
4.00390625),
(constants.KPRO3_AN5_1, constants.KPRO3_AN5_2, 3, 52, 5,
4.00390625),
(constants.KPRO3_AN6_1, constants.KPRO3_AN6_2, 3, 52, 6,
4.00390625),
(constants.KPRO3_AN7_1, constants.KPRO3_AN7_2, 3, 52, 7,
4.00390625),
),
)
def test_analog_input_v3(self, index1, index2, value1, value2, channel,
result):
self.kpro.version = constants.KPRO23_ID
self.kpro.data5[index2] = value2
self.kpro.data5[index1] = value1
assert self.kpro.analog_input(channel) == result
@pytest.mark.parametrize(
"channel, result",
(
(0, 0),
(1, 0),
(2, 0),
(3, 0),
(4, 0),
(5, 0),
(6, 0),
(7, 0),
),
)
def test_analog_input_no_version(self, channel, result):
self.kpro.version = None
assert self.kpro.analog_input(channel) == result
# sudo python bench/test.py
from __future__ import print_function
from reprint import output
from devices.kpro.kpro import Kpro
kpro = Kpro()
with output(output_type="dict", initial_len=1, interval=0) as output_list:
while True:
output_list["ETH"] = str(kpro.eth)
output_list["FLT"] = str(kpro.flt)
output_list["BAT"] = str(kpro.bat)
output_list["CAM"] = str(kpro.cam)
output_list["O2"] = str(kpro.o2)
output_list["IAT"] = str(kpro.iat)
output_list["RPM"] = str(kpro.rpm)
output_list["TPS"] = str(kpro.tps)
output_list["VSS"] = str(kpro.vss)
output_list["ECT"] = str(kpro.ect)
output_list["GEAR"] = str(kpro.gear)
output_list["EPS"] = str(kpro.eps)
output_list["SCS"] = str(kpro.scs)
output_list["RVSLCK"] = str(kpro.rvslck)
output_list["BKSW"] = str(kpro.bksw)
output_list["ACSW"] = str(kpro.acsw)
output_list["ACCL"] = str(kpro.accl)
output_list["FLR"] = str(kpro.flr)
output_list["FANC"] = str(kpro.fanc)
output_list["MAP"] = str(kpro.map)
output_list["AN0"] = str(kpro.analog_input(0))
class TestKpro:
temp_sensor_argvalues = ((51, 69, 156), (40, 80, 175), (31, 91, 195))
def setup_method(self):
# we are not unit testing USB features so it may raise a
# `usb.core.NoBackendError` e.g. on Docker
with mock.patch("devices.kpro.kpro.Kpro.__init__") as m___init__:
m___init__.return_value = None
self.kpro = Kpro()
self.kpro.data0 = [None for _ in range(38)]
self.kpro.data1 = [None for _ in range(6)]
self.kpro.data3 = [None for _ in range(82)]
self.kpro.data4 = [None for _ in range(18)]
def test_battery_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data1[4] = 123
assert self.kpro.bat() == 12.3
def test_rpm_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[2] = 100
self.kpro.data0[3] = 100
assert self.kpro.rpm() == 6425
def test_tps_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[5] = 100
assert self.kpro.tps() == 37
def test_o2_v4_valid(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[constants.KPRO4_AFR1] = 0
self.kpro.data0[constants.KPRO4_AFR2] = 128
assert self.kpro.o2()["afr"] == 14.7
assert self.kpro.o2()["lambda"] == 1
def test_o2_v23_valid(self):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[constants.KPRO23_AFR1] = 0
self.kpro.data0[constants.KPRO23_AFR2] = 128
assert self.kpro.o2()["afr"] == 14.7
assert self.kpro.o2()["lambda"] == 1
def test_o2_v4_division_by_zero(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[constants.KPRO4_AFR1] = 0
self.kpro.data0[constants.KPRO4_AFR2] = 0
assert self.kpro.o2()["afr"] == 0
assert self.kpro.o2()["lambda"] == 0
def test_vss_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[4] = 100
assert self.kpro.vss()["kmh"] == 100
assert self.kpro.vss()["mph"] == 62
def test_vss_v23(self):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[6] = 100
assert self.kpro.vss()["kmh"] == 100
assert self.kpro.vss()["mph"] == 62
@pytest.mark.parametrize("kpro_value, value_cls, value_fht", temp_sensor_argvalues)
def test_ect_v4(self, kpro_value, value_cls, value_fht):
self.kpro.version = constants.KPRO4_ID
self.kpro.data1[2] = kpro_value
assert self.kpro.ect()["celsius"] == value_cls
assert self.kpro.ect()["fahrenheit"] == value_fht
@pytest.mark.parametrize("kpro_value, value_cls, value_fht", temp_sensor_argvalues)
def test_ect_v23(self, kpro_value, value_cls, value_fht):
self.kpro.version = constants.KPRO23_ID
self.kpro.data1[4] = kpro_value
assert self.kpro.ect()["celsius"] == value_cls
assert self.kpro.ect()["fahrenheit"] == value_fht
@pytest.mark.parametrize("kpro_value, value_cls, value_fht", temp_sensor_argvalues)
def test_iat_v4(self, kpro_value, value_cls, value_fht):
self.kpro.version = constants.KPRO4_ID
self.kpro.data1[3] = kpro_value
assert self.kpro.iat()["celsius"] == value_cls
assert self.kpro.iat()["fahrenheit"] == value_fht
@pytest.mark.parametrize("kpro_value, value_cls, value_fht", temp_sensor_argvalues)
def test_iat_v23(self, kpro_value, value_cls, value_fht):
self.kpro.version = constants.KPRO23_ID
self.kpro.data1[5] = kpro_value
assert self.kpro.iat()["celsius"] == value_cls
assert self.kpro.iat()["fahrenheit"] == value_fht
def test_map_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[6] = 100
assert self.kpro.map()["bar"] == 1
assert self.kpro.map()["mbar"] == 1000
assert self.kpro.map()["psi"] == 14.503773773
def test_map_v23(self):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[8] = 100
assert self.kpro.map()["bar"] == 1
assert self.kpro.map()["mbar"] == 1000
assert self.kpro.map()["psi"] == 14.503773773
@pytest.mark.parametrize("kpro_value, result", ((100, 30.0),))
def test_cam_v23(self, kpro_value, result):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[constants.KPRO23_CAM] = kpro_value
assert self.kpro.cam() == result
@pytest.mark.parametrize("kpro_value, result", ((100, 30.0),))
def test_cam_v4(self, kpro_value, result):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[constants.KPRO4_CAM] = kpro_value
assert self.kpro.cam() == result
@pytest.mark.parametrize("kpro_value, result", ((0, "N"), (1, 1)))
def test_gear_v23(self, kpro_value, result):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[constants.KPRO23_GEAR] = kpro_value
assert self.kpro.gear() == result
@pytest.mark.parametrize("kpro_value, result", ((0, "N"), (1, 1)))
def test_gear_v4(self, kpro_value, result):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[constants.KPRO4_GEAR] = kpro_value
assert self.kpro.gear() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (32, True)))
def test_eps_v23(self, kpro_value, result):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[constants.KPRO23_EPS] = kpro_value
assert self.kpro.eps() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (32, True)))
def test_eps_v4(self, kpro_value, result):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[constants.KPRO4_EPS] = kpro_value
assert self.kpro.eps() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (16, True)))
def test_scs_v23(self, kpro_value, result):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[constants.KPRO23_SCS] = kpro_value
assert self.kpro.scs() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (16, True)))
def test_scs_v4(self, kpro_value, result):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[constants.KPRO4_SCS] = kpro_value
assert self.kpro.scs() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (1, True)))
def test_rvslck_v23(self, kpro_value, result):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[constants.KPRO23_RVSLCK] = kpro_value
assert self.kpro.rvslck() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (1, True)))
def test_rvslck_v4(self, kpro_value, result):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[constants.KPRO4_RVSLCK] = kpro_value
assert self.kpro.rvslck() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (2, True)))
def test_bksw_v23(self, kpro_value, result):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[constants.KPRO23_BKSW] = kpro_value
assert self.kpro.bksw() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (2, True)))
def test_bksw_v4(self, kpro_value, result):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[constants.KPRO4_BKSW] = kpro_value
assert self.kpro.bksw() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (4, True)))
def test_acsw_v23(self, kpro_value, result):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[constants.KPRO23_ACSW] = kpro_value
assert self.kpro.acsw() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (4, True)))
def test_acsw_v4(self, kpro_value, result):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[constants.KPRO4_ACSW] = kpro_value
assert self.kpro.acsw() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (8, True)))
def test_accl_v23(self, kpro_value, result):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[constants.KPRO23_ACCL] = kpro_value
assert self.kpro.accl() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (8, True)))
def test_accl_v4(self, kpro_value, result):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[constants.KPRO4_ACCL] = kpro_value
assert self.kpro.accl() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (64, True)))
def test_flr_v23(self, kpro_value, result):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[constants.KPRO23_FLR] = kpro_value
assert self.kpro.flr() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (64, True)))
def test_flr_v4(self, kpro_value, result):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[constants.KPRO4_FLR] = kpro_value
assert self.kpro.flr() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (128, True)))
def test_fanc_v23(self, kpro_value, result):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[constants.KPRO23_FANC] = kpro_value
assert self.kpro.fanc() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (128, True)))
def test_fanc_v4(self, kpro_value, result):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[constants.KPRO4_FANC] = kpro_value
assert self.kpro.fanc() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (1, True)))
def test_ign_v23(self, kpro_value, result):
self.kpro.version = constants.KPRO23_ID
self.kpro.data4[constants.KPRO23_IGN] = kpro_value
assert self.kpro.ign() == result
@pytest.mark.parametrize("kpro_value, result", ((0, False), (1, True)))
def test_ign_v4(self, kpro_value, result):
self.kpro.version = constants.KPRO4_ID
self.kpro.data4[constants.KPRO4_IGN] = kpro_value
assert self.kpro.ign() == result
def test_analog_input_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data3[66] = 52
self.kpro.data3[67] = 3
self.kpro.data3[68] = 52
self.kpro.data3[69] = 3
self.kpro.data3[70] = 52
self.kpro.data3[71] = 3
self.kpro.data3[72] = 52
self.kpro.data3[73] = 3
self.kpro.data3[74] = 52
self.kpro.data3[75] = 3
self.kpro.data3[76] = 52
self.kpro.data3[77] = 3
self.kpro.data3[78] = 52
self.kpro.data3[79] = 3
self.kpro.data3[80] = 52
self.kpro.data3[81] = 3
assert self.kpro.analog_input(0) == 1.0009765625
assert self.kpro.analog_input(1) == 1.0009765625
assert self.kpro.analog_input(2) == 1.0009765625
assert self.kpro.analog_input(3) == 1.0009765625
assert self.kpro.analog_input(4) == 1.0009765625
assert self.kpro.analog_input(5) == 1.0009765625
assert self.kpro.analog_input(6) == 1.0009765625
assert self.kpro.analog_input(7) == 1.0009765625
class Backend:
_instance = None
def __init__(self):
self._init_websocket()
self._load_user_preferences()
self._init_resources()
@staticmethod
def _init_websocket():
websocket_started = False
while not websocket_started:
try:
app.run()
websocket_started = app._started
except AlreadyRunningError:
app.stop()
except (ConnectionRefusedError, TimeoutError):
# Crossbar router not yet accepting connections, let's try again
pass
def _init_resources(self):
self.time = Time()
self.odo = Odometer()
self.kpro = Kpro()
def _load_user_preferences(self):
"""
In order to read only once from the setup file
we will load in memory some user preferences that we are gonna use later on.
"""
self.setup_file = SetupFile()
self.style = Style(
self.setup_file.json.get("style").get("tpsLowerThreshold"),
self.setup_file.json.get("style").get("tpsUpperThreshold"),
self.setup_file.json.get("style").get("elapsedSeconds"),
)
self.iat_unit = self.setup_file.json.get("iat",
{}).get("unit", "celsius")
self.ect_unit = self.setup_file.json.get("ect",
{}).get("unit", "celsius")
self.vss_unit = self.setup_file.json.get("vss", {}).get("unit", "kmh")
self.o2_unit = self.setup_file.json.get("o2", {}).get("unit", "afr")
self.odo_unit = self.setup_file.json.get("odo", {}).get("unit", "km")
self.map_unit = self.setup_file.json.get("map", {}).get("unit", "bar")
self.an0_unit = self.setup_file.json.get("an0",
{}).get("unit", "volts")
self.an1_unit = self.setup_file.json.get("an1",
{}).get("unit", "volts")
self.an2_unit = self.setup_file.json.get("an2",
{}).get("unit", "volts")
self.an3_unit = self.setup_file.json.get("an3",
{}).get("unit", "volts")
self.an4_unit = self.setup_file.json.get("an4",
{}).get("unit", "volts")
self.an5_unit = self.setup_file.json.get("an5",
{}).get("unit", "volts")
self.an6_unit = self.setup_file.json.get("an6",
{}).get("unit", "volts")
self.an7_unit = self.setup_file.json.get("an7",
{}).get("unit", "volts")
self.an0_formula = self.setup_file.get_formula("an0")
self.an1_formula = self.setup_file.get_formula("an1")
self.an2_formula = self.setup_file.get_formula("an2")
self.an3_formula = self.setup_file.get_formula("an3")
self.an4_formula = self.setup_file.get_formula("an4")
self.an5_formula = self.setup_file.get_formula("an5")
self.an6_formula = self.setup_file.get_formula("an6")
self.an7_formula = self.setup_file.get_formula("an7")
def update(self):
""" load the websocket with updated info """
if not self.kpro.status: # if kpro is down try to reconnect
self.kpro.find_and_connect()
self.odo.save(self.kpro.vss["kmh"])
self.style.update(self.kpro.tps)
publish(
"data",
{
"bat": self.kpro.bat,
"gear": self.kpro.gear,
"iat": self.kpro.iat[self.iat_unit],
"tps": self.kpro.tps,
"ect": self.kpro.ect[self.ect_unit],
"rpm": self.kpro.rpm,
"vss": self.kpro.vss[self.vss_unit],
"o2": self.kpro.o2[self.o2_unit],
"cam": self.kpro.cam,
"mil": self.kpro.mil,
"fan": self.kpro.fanc,
"bksw": self.kpro.bksw,
"flr": self.kpro.flr,
"eth": self.kpro.eth,
"scs": self.kpro.scs,
"fmw": self.kpro.firmware,
"map": self.kpro.map[self.map_unit],
"an0": self.an0_formula(
self.kpro.analog_input(0))[self.an0_unit],
"an1": self.an1_formula(
self.kpro.analog_input(1))[self.an1_unit],
"an2": self.an2_formula(
self.kpro.analog_input(2))[self.an2_unit],
"an3": self.an3_formula(
self.kpro.analog_input(3))[self.an3_unit],
"an4": self.an4_formula(
self.kpro.analog_input(4))[self.an4_unit],
"an5": self.an5_formula(
self.kpro.analog_input(5))[self.an5_unit],
"an6": self.an6_formula(
self.kpro.analog_input(6))[self.an6_unit],
"an7": self.an7_formula(
self.kpro.analog_input(7))[self.an7_unit],
"time": self.time.get_time(),
"odo": self.odo.get_mileage()[self.odo_unit],
"style": self.style.status,
"ver": __version__,
},
)
def _setup(self):
return self.setup_file.load_setup()
def _save(self, new_setup):
self.setup_file.save_setup(new_setup)
self.setup_file.rotate_screen(new_setup["screen"]["rotate"])
publish(
"refresh") # refresh the frontend so the new changes are applied
self._load_user_preferences() # refresh the backend too
def _reset(self):
self.setup_file.reset_setup()
publish(
"refresh") # refresh the frontend so the new changes are applied
self._load_user_preferences() # refresh the backend too
@classmethod
def get(cls):
""" get the running instance of Backend class or instantiate it for first time """
if cls._instance is None:
cls._instance = cls()
return cls._instance
@classmethod
def setup(cls):
return cls.get()._setup()
@classmethod
def save(cls, new_setup):
cls.get()._save(new_setup)
@classmethod
def reset(cls):
cls.get()._reset()
class TestKpro(TestCase):
def setUp(self):
# we are not unit testing USB features so it may raise a
# `usb.core.NoBackendError` e.g. on Docker
with mock.patch('devices.kpro.kpro.Kpro.__init__') as m___init__:
m___init__.return_value = None
self.kpro = Kpro()
self.kpro.data0 = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0
]
self.kpro.data1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
self.kpro.data3 = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
def test_battery_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data1[4] = 123
self.assertEqual(self.kpro.bat(), 12.3)
def test_rpm_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[2] = 100
self.kpro.data0[3] = 100
self.assertEqual(self.kpro.rpm(), 6425)
def test_tps_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[5] = 100
self.assertEqual(self.kpro.tps(), 37)
def test_o2_v4_valid(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[16] = 0
self.kpro.data0[17] = 128
self.assertEqual(self.kpro.o2()['afr'], 14.7)
self.assertEqual(self.kpro.o2()['lambda'], 1)
def test_o2_v23_valid(self):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[18] = 0
self.kpro.data0[19] = 128
self.assertEqual(self.kpro.o2()['afr'], 14.7)
self.assertEqual(self.kpro.o2()['lambda'], 1)
def test_o2_v4_division_by_zero(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[18] = 0
self.kpro.data0[19] = 0
self.assertEqual(self.kpro.o2()['afr'], 0)
self.assertEqual(self.kpro.o2()['lambda'], 0)
def test_vss_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[4] = 100
self.assertEqual(self.kpro.vss()['kmh'], 100)
self.assertEqual(self.kpro.vss()['mph'], 62)
def test_vss_v23(self):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[6] = 100
self.assertEqual(self.kpro.vss()['kmh'], 100)
self.assertEqual(self.kpro.vss()['mph'], 62)
def test_ect_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data1[2] = 31
self.assertEqual(self.kpro.ect()['celsius'], 90)
self.assertEqual(self.kpro.ect()['fahrenheit'], 194)
def test_ect_v23(self):
self.kpro.version = constants.KPRO23_ID
self.kpro.data1[4] = 31
self.assertEqual(self.kpro.ect()['celsius'], 90)
self.assertEqual(self.kpro.ect()['fahrenheit'], 194)
def test_iat_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data1[3] = 31
self.assertEqual(self.kpro.iat()['celsius'], 90)
self.assertEqual(self.kpro.iat()['fahrenheit'], 194)
def test_iat_v23(self):
self.kpro.version = constants.KPRO23_ID
self.kpro.data1[5] = 31
self.assertEqual(self.kpro.iat()['celsius'], 90)
self.assertEqual(self.kpro.iat()['fahrenheit'], 194)
def test_map_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data0[6] = 100
self.assertEqual(self.kpro.map()['bar'], 1)
self.assertEqual(self.kpro.map()['mbar'], 1000)
self.assertEqual(self.kpro.map()['psi'], 14.503773773)
def test_map_v23(self):
self.kpro.version = constants.KPRO23_ID
self.kpro.data0[8] = 100
self.assertEqual(self.kpro.map()['bar'], 1)
self.assertEqual(self.kpro.map()['mbar'], 1000)
self.assertEqual(self.kpro.map()['psi'], 14.503773773)
def test_analog_input_v4(self):
self.kpro.version = constants.KPRO4_ID
self.kpro.data3[66] = 52
self.kpro.data3[67] = 3
self.kpro.data3[68] = 52
self.kpro.data3[69] = 3
self.kpro.data3[70] = 52
self.kpro.data3[71] = 3
self.kpro.data3[72] = 52
self.kpro.data3[73] = 3
self.kpro.data3[74] = 52
self.kpro.data3[75] = 3
self.kpro.data3[76] = 52
self.kpro.data3[77] = 3
self.kpro.data3[78] = 52
self.kpro.data3[79] = 3
self.kpro.data3[80] = 52
self.kpro.data3[81] = 3
self.assertEqual(self.kpro.analog_input(0), 1.0009765625)
self.assertEqual(self.kpro.analog_input(1), 1.0009765625)
self.assertEqual(self.kpro.analog_input(2), 1.0009765625)
self.assertEqual(self.kpro.analog_input(3), 1.0009765625)
self.assertEqual(self.kpro.analog_input(4), 1.0009765625)
self.assertEqual(self.kpro.analog_input(5), 1.0009765625)
self.assertEqual(self.kpro.analog_input(6), 1.0009765625)
self.assertEqual(self.kpro.analog_input(7), 1.0009765625)
def _init_resources(self):
self.time = Time()
self.odo = Odometer()
self.kpro = Kpro()
def save(new_setup):
setup_file.save_setup(new_setup)
setup_file.rotate_screen(new_setup['screen']['rotate'])
while True:
try:
run()
break
except Exception:
continue
time = Time()
setup_file = SetupFile()
odo = Odometer()
kpro = Kpro()
iat_unit = setup_file.json.get('iat', {}).get('unit', 'celsius')
ect_unit = setup_file.json.get('ect', {}).get('unit', 'celsius')
vss_unit = setup_file.json.get('vss', {}).get('unit', 'kmh')
o2_unit = setup_file.json.get('o2', {}).get('unit', 'afr')
odo_unit = setup_file.json.get('odo', {}).get('unit', 'km')
map_unit = setup_file.json.get('map', {}).get('unit', 'bar')
an0_unit = setup_file.json.get('an0', {}).get('unit', 'volts')
an1_unit = setup_file.json.get('an1', {}).get('unit', 'volts')
an2_unit = setup_file.json.get('an2', {}).get('unit', 'volts')
an3_unit = setup_file.json.get('an3', {}).get('unit', 'volts')
an4_unit = setup_file.json.get('an4', {}).get('unit', 'volts')
an5_unit = setup_file.json.get('an5', {}).get('unit', 'volts')
an6_unit = setup_file.json.get('an6', {}).get('unit', 'volts')
an7_unit = setup_file.json.get('an7', {}).get('unit', 'volts')