rusefi-1/firmware/controllers/bench_test.cpp

/**
 * @file    bench_test.cpp
 * @brief	Utility methods related to bench testing.
 *
 *
 * @date Sep 8, 2013
 * @author Andrey Belomutskiy, (c) 2012-2020
 *
 * This file is part of rusEfi - see http://rusefi.com
 *
 * rusEfi is free software; you can redistribute it and/or modify it under the terms of
 * the GNU General Public License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 *
 * rusEfi is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
 * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <http://www.gnu.org/licenses/>.
 */

// todo: rename this file
#include "global.h"

#if EFI_ENGINE_CONTROL
#if !EFI_UNIT_TEST

#include "os_access.h"
#include "flash_main.h"
#include "bench_test.h"
#include "io_pins.h"
#include "main_trigger_callback.h"
#include "engine_configuration.h"
#include "pin_repository.h"
#include "efi_gpio.h"
#include "settings.h"
#include "idle_thread.h"
#include "periodic_thread_controller.h"
#include "tps.h"
#include "electronic_throttle.h"
#include "cj125.h"
#include "malfunction_central.h"
#include "tunerstudio_outputs.h"

#if EFI_PROD_CODE
#include "rusefi.h"
#include "mpu_util.h"
#endif /* EFI_PROD_CODE */

#if (BOARD_TLE8888_COUNT > 0)
#include "gpio/tle8888.h"
#endif



EXTERN_ENGINE;

static Logging * logger;
static bool isRunningBench = false;

bool isRunningBenchTest(void) {
	return isRunningBench;
}

static void runBench(brain_pin_e brainPin, OutputPin *output, float delayMs, float onTimeMs, float offTimeMs,
		int count) {
    int delaySt = delayMs < 1 ? 1 : TIME_MS2I(delayMs);
	int onTimeSt = onTimeMs < 1 ? 1 : TIME_MS2I(onTimeMs);
	int offTimeSt = offTimeMs < 1 ? 1 : TIME_MS2I(offTimeMs);
	if (delaySt < 0) {
		scheduleMsg(logger, "Invalid delay %.2f", delayMs);
		return;
	}
	if (onTimeSt <= 0) {
		scheduleMsg(logger, "Invalid onTime %.2f", onTimeMs);
		return;
	}
	if (offTimeSt <= 0) {
		scheduleMsg(logger, "Invalid offTime %.2f", offTimeMs);
		return;
	}
	scheduleMsg(logger, "Running bench: ON_TIME=%.2f ms OFF_TIME=%.2fms Counter=%d", onTimeMs, offTimeMs, count);
	scheduleMsg(logger, "output on %s", hwPortname(brainPin));

	if (delaySt != 0) {
		chThdSleep(delaySt);
	}

	isRunningBench = true;
	for (int i = 0; i < count; i++) {
		output->setValue(true);
		chThdSleep(onTimeSt);
		output->setValue(false);
		chThdSleep(offTimeSt);
	}
	scheduleMsg(logger, "Done!");
	isRunningBench = false;
}

static volatile bool isBenchTestPending = false;
static float onTime;
static float offTime;
static float delayMs;
static int count;
static brain_pin_e brainPin;
static OutputPin* pinX;

static void pinbench(const char *delayStr, const char *onTimeStr, const char *offTimeStr, const char *countStr,
		OutputPin* pinParam, brain_pin_e brainPinParam) {
	delayMs = atoff(delayStr);
	onTime = atoff(onTimeStr);
	offTime = atoff(offTimeStr);
	count = atoi(countStr);

	brainPin = brainPinParam;
	pinX = pinParam;
	isBenchTestPending = true; // let's signal bench thread to wake up
}

static void doRunFuel(int humanIndex, const char *delayStr, const char * onTimeStr, const char *offTimeStr,
		const char *countStr) {
	if (humanIndex < 1 || humanIndex > engineConfiguration->specs.cylindersCount) {
		scheduleMsg(logger, "Invalid index: %d", humanIndex);
		return;
	}
	brain_pin_e b = CONFIG(injectionPins)[humanIndex - 1];
	pinbench(delayStr, onTimeStr, offTimeStr, countStr, &enginePins.injectors[humanIndex - 1], b);
}

static void doBenchTestFsio(int humanIndex, const char *delayStr, const char * onTimeStr, const char *offTimeStr,
		const char *countStr) {
	if (humanIndex < 1 || humanIndex > FSIO_COMMAND_COUNT) {
		scheduleMsg(logger, "Invalid index: %d", humanIndex);
		return;
	}
	brain_pin_e b = CONFIG(fsioOutputPins)[humanIndex - 1];
	pinbench(delayStr, onTimeStr, offTimeStr, countStr, &enginePins.fsioOutputs[humanIndex - 1], b);
}

/**
 * delay 100, cylinder #2, 5ms ON, 1000ms OFF, repeat 3 times
 * fuelbench2 100 2 5 1000 3
 */
static void fuelbench2(const char *delayStr, const char *indexStr, const char * onTimeStr, const char *offTimeStr,
		const char *countStr) {
	int index = atoi(indexStr);
	doRunFuel(index, delayStr, onTimeStr, offTimeStr, countStr);
}

/**
 * delay 100, channel #1, 5ms ON, 1000ms OFF, repeat 3 times
 * fsiobench2 100 1 5 1000 3
 */
static void fsioBench2(const char *delayStr, const char *indexStr, const char * onTimeStr, const char *offTimeStr,
		const char *countStr) {
	int index = atoi(indexStr);
	doBenchTestFsio(index, delayStr, onTimeStr, offTimeStr, countStr);
}

static void fanBenchExt(const char *durationMs) {
	pinbench("0", durationMs, "100", "1", &enginePins.fanRelay, CONFIG(fanPin));
}

void fanBench(void) {
	fanBenchExt("3000");
}

/**
 * we are blinking for 16 seconds so that one can click the button and walk around to see the light blinking
 */
void milBench(void) {
	pinbench("0", "500", "500", "16", &enginePins.checkEnginePin, CONFIG(malfunctionIndicatorPin));
}

void starterRelayBench(void) {
	pinbench("0", "6000", "100", "1", &enginePins.starterControl, CONFIG(starterControlPin));
}

void fuelPumpBenchExt(const char *durationMs) {
	pinbench("0", durationMs, "100", "1", &enginePins.fuelPumpRelay, CONFIG(fuelPumpPin));
}

void acRelayBench(void) {
	pinbench("0", "1000", "100", "1", &enginePins.acRelay, CONFIG(acRelayPin));
}

void mainRelayBench(void) {
	pinbench("0", "1000", "100", "1", &enginePins.mainRelay, CONFIG(mainRelayPin));
}

void hpfpValveBench(void) {
	pinbench(/*delay*/"1000", /* onTime */"20", /*oftime*/"500", "3", &enginePins.hpfpValve, CONFIG(hpfpValvePin));
}

void fuelPumpBench(void) {
	fuelPumpBenchExt("3000");
}

// fuelbench 5 1000 2
static void fuelbench(const char * onTimeStr, const char *offTimeStr, const char *countStr) {
	fuelbench2("0", "1", onTimeStr, offTimeStr, countStr);
}

static void doRunSpark(int humanIndex, const char *delayStr, const char * onTimeStr, const char *offTimeStr,
		const char *countStr) {
	if (humanIndex < 1 || humanIndex > engineConfiguration->specs.cylindersCount) {
		scheduleMsg(logger, "Invalid index: %d", humanIndex);
		return;
	}
	brain_pin_e b = CONFIG(ignitionPins)[humanIndex - 1];
	pinbench(delayStr, onTimeStr, offTimeStr, countStr, &enginePins.coils[humanIndex - 1], b);
}

/**
 * sparkbench2 0 1 5 1000 2
 */
static void sparkbench2(const char *delayStr, const char *indexStr, const char * onTimeStr, const char *offTimeStr,
		const char *countStr) {
	int index = atoi(indexStr);
	doRunSpark(index, delayStr, onTimeStr, offTimeStr, countStr);
}

/**
 * sparkbench 5 400 2
 * 5 ms ON, 400 ms OFF, two times
 */
static void sparkbench(const char * onTimeStr, const char *offTimeStr, const char *countStr) {
	sparkbench2("0", "1", onTimeStr, offTimeStr, countStr);
}

class BenchController : public PeriodicController<UTILITY_THREAD_STACK_SIZE> {
public:
	BenchController() : PeriodicController("BenchThread") { }
private:
	void PeriodicTask(efitick_t nowNt) override	{
		UNUSED(nowNt);
		setPeriod(50 /* ms */);

		validateStack("Bench", STACK_USAGE_BENCH, 128);

		// naive inter-thread communication - waiting for a flag
		if (isBenchTestPending) {
			isBenchTestPending = false;
			runBench(brainPin, pinX, delayMs, onTime, offTime, count);
		}
	}
};

static BenchController instance;

static void handleBenchCategory(uint16_t index) {
	switch(index) {
	case CMD_TS_BENCH_MAIN_RELAY:
		mainRelayBench();
		return;
	case CMD_TS_BENCH_HPFP_VALVE:
		hpfpValveBench();
		return;
	case CMD_TS_BENCH_FUEL_PUMP:
		// cmd_test_fuel_pump
		fuelPumpBench();
		return;
	case CMD_TS_BENCH_STARTER_ENABLE_RELAY:
		starterRelayBench();
		return;
	case CMD_TS_BENCH_CHECK_ENGINE_LIGHT:
		// cmd_test_check_engine_light
		milBench();
		return;
	case CMD_TS_BENCH_AC_COMPRESSOR_RELAY:
		acRelayBench();
		return;
	}

}

static void handleCommandX14(uint16_t index) {
	switch (index) {
	case 2:
		grabTPSIsClosed();
		return;
	case 3:
		grabTPSIsWideOpen();
		return;
	// case 4: tps2_closed
	// case 5: tps2_wot
	case 6:
		grabPedalIsUp();
		return;
	case 7:
		grabPedalIsWideOpen();
		return;
	case 8:
#if (BOARD_TLE8888_COUNT > 0)
		tle8888_req_init();
#endif
		return;
	case 0xA:
		// cmd_write_config
#if EFI_INTERNAL_FLASH
		writeToFlashNow();
#endif /* EFI_INTERNAL_FLASH */
		return;
	case 0xD:
		engine->directSelfStimulation = true;
		return;
#if EFI_ELECTRONIC_THROTTLE_BODY
	case 0xE:
		etbAutocal(0);
		return;
	case 0x11:
		etbAutocal(1);
		return;
	case 0xC:
		engine->etbAutoTune = true;
		return;
	case 0x10:
		engine->etbAutoTune = false;
#if EFI_TUNER_STUDIO
		tsOutputChannels.calibrationMode = TsCalMode::None;
#endif // EFI_TUNER_STUDIO
		return;
#endif
	case 0xF:
		engine->directSelfStimulation = false;
		return;
	}
}

extern bool rebootForPresetPending;

static void fatalErrorForPresetApply() {
	rebootForPresetPending = true;
	firmwareError(OBD_PCM_Processor_Fault,
		"\n\nTo complete preset apply:\n"
		"   1. Close TunerStudio\n"
		"   2. Power cycle ECU\n"
		"   3. Open TunerStudio and reconnect\n\n");
}

// todo: this is probably a wrong place for this method now
void executeTSCommand(uint16_t subsystem, uint16_t index) {
	scheduleMsg(logger, "IO test subsystem=%d index=%d", subsystem, index);

	bool running = !ENGINE(rpmCalculator).isStopped();

    if (subsystem == 0x11) {
        clearWarnings();
	} else if (subsystem == CMD_TS_IGNITION_CATEGORY && !running) {
		doRunSpark(index, "300", "4", "400", "3");
	} else if (subsystem == CMD_TS_INJECTOR_CATEGORY && !running) {
		doRunFuel(index, "300", "4", "400", "3");
	} else if (subsystem == CMD_TS_FSIO_CATEGORY && !running) {
		doBenchTestFsio(index, "300", "4", "400", "3");
	} else if (subsystem == 0x14) {
		handleCommandX14(index);
	} else if (subsystem == 0x15) {
		fanBench();
	} else if (subsystem == CMD_TS_BENCH_CATEGORY) {
		handleBenchCategory(index);
	} else if (subsystem == 0x17) {
		// cmd_test_idle_valve
#if EFI_IDLE_CONTROL
		startIdleBench();
#endif /* EFI_IDLE_CONTROL */
	} else if (subsystem == 0x18) {
#if EFI_CJ125 && HAL_USE_SPI
		cjStartCalibration();
#endif /* EFI_CJ125 */
	} else if (subsystem == 0x20 && index == 0x3456) {
		// call to pit
		setCallFromPitStop(30000);
	} else if (subsystem == 0x30) {
		fatalErrorForPresetApply();
		setEngineType(index);
	} else if (subsystem == 0x31) {
		fatalErrorForPresetApply();
		setEngineType(DEFAULT_ENGINE_TYPE);
	} else if (subsystem == 0x79) {
		scheduleStopEngine();
	} else if (subsystem == 0xba) {
#if EFI_PROD_CODE
		jump_to_bootloader();
#endif /* EFI_PROD_CODE */
	} else if (subsystem == 0xbb) {
#if EFI_PROD_CODE
		rebootNow();
#endif /* EFI_PROD_CODE */
	}
}

void initBenchTest(Logging *sharedLogger) {
	logger = sharedLogger;

	addConsoleAction("fuelpumpbench", fuelPumpBench);
	addConsoleAction("acrelaybench", acRelayBench);
	addConsoleActionS("fuelpumpbench2", fuelPumpBenchExt);
	addConsoleAction("fanbench", fanBench);
	addConsoleActionS("fanbench2", fanBenchExt);

	addConsoleAction(CMD_STARTER_BENCH, starterRelayBench);
	addConsoleAction(CMD_MIL_BENCH, milBench);
	addConsoleActionSSS(CMD_FUEL_BENCH, fuelbench);
	addConsoleActionSSS("sparkbench", sparkbench);
	addConsoleAction(CMD_HPFP_BENCH, hpfpValveBench);

	addConsoleActionSSSSS("fuelbench2", fuelbench2);
	addConsoleActionSSSSS("fsiobench2", fsioBench2);
	addConsoleActionSSSSS("sparkbench2", sparkbench2);
	instance.setPeriod(200 /*ms*/);
	instance.Start();
}

#endif /* EFI_UNIT_TEST */
#endif