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()