rusefi
/
rusefi-full
mirror of https://github.com/rusefi/rusefi-full.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

auto-sync

This commit is contained in:
rusEfi 2015-01-12 22:03:39 -06:00
parent 2a05e2cd65
commit c951cf27a9
14 changed files with 162 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
firmware/console/status_loop.cpp
View File

@ -64,7 +64,7 @@
#include "vehicle_speed.h" #include "vehicle_speed.h"
#endif #endif
extern OutputPin outputs[IO_PIN_COUNT]; extern engine_pins_s enginePins;
// this 'true' value is needed for simulator // this 'true' value is needed for simulator
static volatile bool fullLog = true; static volatile bool fullLog = true;
@ -354,7 +354,7 @@ static void showFuelInfo2(float rpm, float engineLoad, Engine *engine) {
scheduleMsg(&logger, "SD magic fuel %f", sdMath(engineConfiguration, 100, 100, 14.7, convertCelsiusToKelvin(20))); scheduleMsg(&logger, "SD magic fuel %f", sdMath(engineConfiguration, 100, 100, 14.7, convertCelsiusToKelvin(20)));
scheduleMsg(&logger2, "algo=%s/pump=%s", getEngine_load_mode_e(engineConfiguration->algorithm), scheduleMsg(&logger2, "algo=%s/pump=%s", getEngine_load_mode_e(engineConfiguration->algorithm),
boolToString(getOutputPinValue(FUEL_PUMP_RELAY))); boolToString(enginePins.fuelPumpRelay.getLogicValue()));
scheduleMsg(&logger2, "cranking fuel: %f", getCrankingFuel(engine)); scheduleMsg(&logger2, "cranking fuel: %f", getCrankingFuel(engine));
@ -515,9 +515,9 @@ void updateTunerStudioState(Engine *engine, TunerStudioOutputChannels *tsOutputC
tsOutputChannels->needBurn = getNeedToWriteConfiguration(); tsOutputChannels->needBurn = getNeedToWriteConfiguration();
tsOutputChannels->hasSdCard = isSdCardAlive(); tsOutputChannels->hasSdCard = isSdCardAlive();
tsOutputChannels->isFuelPumpOn = getOutputPinValue(FUEL_PUMP_RELAY); tsOutputChannels->isFuelPumpOn = enginePins.fuelPumpRelay.getLogicValue();
tsOutputChannels->isFanOn = getOutputPinValue(FAN_RELAY); tsOutputChannels->isFanOn = enginePins.fanRelay.getLogicValue();
tsOutputChannels->isO2HeaterOn = getOutputPinValue(O2_HEATER); tsOutputChannels->isO2HeaterOn = enginePins.o2heater.getLogicValue();
tsOutputChannels->ignition_enabled = engineConfiguration->isIgnitionEnabled; tsOutputChannels->ignition_enabled = engineConfiguration->isIgnitionEnabled;
tsOutputChannels->injection_enabled = engineConfiguration->isInjectionEnabled; tsOutputChannels->injection_enabled = engineConfiguration->isInjectionEnabled;
tsOutputChannels->cylinder_cleanup_enabled = engineConfiguration->isCylinderCleanupEnabled; tsOutputChannels->cylinder_cleanup_enabled = engineConfiguration->isCylinderCleanupEnabled;

52
firmware/controllers/algo/auto_generated_enums.cpp
View File

@ -5,46 +5,6 @@
#include "io_pins.h" #include "io_pins.h"
const char *getIo_pin_e(io_pin_e value){ const char *getIo_pin_e(io_pin_e value){
switch(value) { switch(value) {
case AC_RELAY:
return "AC_RELAY";
case ALTERNATOR_SWITCH:
return "ALTERNATOR_SWITCH";
case FAN_RELAY:
return "FAN_RELAY";
case FUEL_PUMP_RELAY:
return "FUEL_PUMP_RELAY";
case GPIO_0:
return "GPIO_0";
case GPIO_1:
return "GPIO_1";
case GPIO_10:
return "GPIO_10";
case GPIO_11:
return "GPIO_11";
case GPIO_12:
return "GPIO_12";
case GPIO_13:
return "GPIO_13";
case GPIO_14:
return "GPIO_14";
case GPIO_15:
return "GPIO_15";
case GPIO_2:
return "GPIO_2";
case GPIO_3:
return "GPIO_3";
case GPIO_4:
return "GPIO_4";
case GPIO_5:
return "GPIO_5";
case GPIO_6:
return "GPIO_6";
case GPIO_7:
return "GPIO_7";
case GPIO_8:
return "GPIO_8";
case GPIO_9:
return "GPIO_9";
case INJECTOR_10_OUTPUT: case INJECTOR_10_OUTPUT:
return "INJECTOR_10_OUTPUT"; return "INJECTOR_10_OUTPUT";
case INJECTOR_11_OUTPUT: case INJECTOR_11_OUTPUT:
@ -71,10 +31,6 @@ case INJECTOR_9_OUTPUT:
return "INJECTOR_9_OUTPUT"; return "INJECTOR_9_OUTPUT";
case IO_INVALID: case IO_INVALID:
return "IO_INVALID"; return "IO_INVALID";
case MAIN_RELAY:
return "MAIN_RELAY";
case O2_HEATER:
return "O2_HEATER";
case SPARKOUT_10_OUTPUT: case SPARKOUT_10_OUTPUT:
return "SPARKOUT_10_OUTPUT"; return "SPARKOUT_10_OUTPUT";
case SPARKOUT_11_OUTPUT: case SPARKOUT_11_OUTPUT:
@ -99,14 +55,6 @@ case SPARKOUT_8_OUTPUT:
return "SPARKOUT_8_OUTPUT"; return "SPARKOUT_8_OUTPUT";
case SPARKOUT_9_OUTPUT: case SPARKOUT_9_OUTPUT:
return "SPARKOUT_9_OUTPUT"; return "SPARKOUT_9_OUTPUT";
case SPI_CS_1:
return "SPI_CS_1";
case SPI_CS_2:
return "SPI_CS_2";
case SPI_CS_3:
return "SPI_CS_3";
case SPI_CS_4:
return "SPI_CS_4";
} }
return NULL; return NULL;
} }

4
firmware/controllers/algo/engine.cpp
View File

@ -23,6 +23,8 @@
static Logging logger; static Logging logger;
extern OutputPin outputs[IO_PIN_COUNT];
EXTERN_ENGINE EXTERN_ENGINE
; ;
@ -56,7 +58,7 @@ void Engine::init() {
} }
static bool stopPin(io_pin_e pin) { static bool stopPin(io_pin_e pin) {
if (getOutputPinValue(pin)) { if (outputs[(int)pin].getLogicValue()) {
setOutputPinValue(pin, 0); setOutputPinValue(pin, 0);
scheduleMsg(&logger, "turning off %s", getPinName(pin)); scheduleMsg(&logger, "turning off %s", getPinName(pin));
return true; return true;

33
firmware/controllers/algo/io_pins.h
View File

@ -44,23 +44,6 @@ typedef enum {
INJECTOR_11_OUTPUT, INJECTOR_11_OUTPUT,
INJECTOR_12_OUTPUT, INJECTOR_12_OUTPUT,
GPIO_0,
GPIO_1,
GPIO_2,
GPIO_3,
GPIO_4,
GPIO_5,
GPIO_6,
GPIO_7,
GPIO_8,
GPIO_9,
GPIO_10,
GPIO_11,
GPIO_12,
GPIO_13,
GPIO_14,
GPIO_15,
IO_INVALID, IO_INVALID,
/** /**
@ -94,22 +77,6 @@ typedef enum {
// LED_HUGE_19, // LED_HUGE_19,
// LED_HUGE_20, // LED_HUGE_20,
FUEL_PUMP_RELAY,
FAN_RELAY,
O2_HEATER,
AC_RELAY,
SPI_CS_1,
SPI_CS_2,
SPI_CS_3,
SPI_CS_4,
MAIN_RELAY,
/**
* This output pin is used to turn alternator on or off
*/
ALTERNATOR_SWITCH,
} io_pin_e; } io_pin_e;

2
firmware/controllers/algo/rusefi_types.h
View File

@ -7,6 +7,8 @@
#ifndef CONTROLLERS_ALGO_RUSEFI_TYPES_H_ #ifndef CONTROLLERS_ALGO_RUSEFI_TYPES_H_
#define CONTROLLERS_ALGO_RUSEFI_TYPES_H_ #define CONTROLLERS_ALGO_RUSEFI_TYPES_H_
#include <stdint.h>
/** /**
* integer time in milliseconds * integer time in milliseconds
* 32 bit 4B / 1000 = 4M seconds = 1111.11 hours = 46 days. * 32 bit 4B / 1000 = 4M seconds = 1111.11 hours = 46 days.

81
firmware/controllers/core/fsio_impl.cpp
View File

@ -32,6 +32,8 @@ static LENameOrdinalPair leFsioSsetting(LE_METHOD_FSIO_SETTING, "fsio_setting");
#define LE_EVAL_POOL_SIZE 32 #define LE_EVAL_POOL_SIZE 32
extern engine_pins_s enginePins;
static LECalculator evalCalc; static LECalculator evalCalc;
static LEElement evalPoolElements[LE_EVAL_POOL_SIZE]; static LEElement evalPoolElements[LE_EVAL_POOL_SIZE];
static LEElementPool evalPool(evalPoolElements, LE_EVAL_POOL_SIZE); static LEElementPool evalPool(evalPoolElements, LE_EVAL_POOL_SIZE);
@ -62,7 +64,7 @@ float getLEValue(Engine *engine, calc_stack_t *s, le_action_e action) {
efiAssert(engine!=NULL, "getLEValue", NAN); efiAssert(engine!=NULL, "getLEValue", NAN);
switch (action) { switch (action) {
case LE_METHOD_FAN: case LE_METHOD_FAN:
return getOutputPinValue(FAN_RELAY); return enginePins.fanRelay.getLogicValue();
case LE_METHOD_AC_TOGGLE: case LE_METHOD_AC_TOGGLE:
return getAcToggle(engine); return getAcToggle(engine);
case LE_METHOD_COOLANT: case LE_METHOD_COOLANT:
@ -147,6 +149,48 @@ static SimplePwm fsioPwm[LE_COMMAND_COUNT] CCM_OPTIONAL;
static LECalculator calc; static LECalculator calc;
extern LEElement * fsioLogics[LE_COMMAND_COUNT]; extern LEElement * fsioLogics[LE_COMMAND_COUNT];
extern OutputPin outputs[IO_PIN_COUNT];
// that's crazy, but what's an alternative? we need const char *, a shared buffer would not work for pin repository
static const char *getGpioPinName(int index) {
switch (index) {
case 0:
return "GPIO_0";
case 1:
return "GPIO_1";
case 10:
return "GPIO_10";
case 11:
return "GPIO_11";
case 12:
return "GPIO_12";
case 13:
return "GPIO_13";
case 14:
return "GPIO_14";
case 15:
return "GPIO_15";
case 2:
return "GPIO_2";
case 3:
return "GPIO_3";
case 4:
return "GPIO_4";
case 5:
return "GPIO_5";
case 6:
return "GPIO_6";
case 7:
return "GPIO_7";
case 8:
return "GPIO_8";
case 9:
return "GPIO_9";
}
return NULL;
}
static OutputPin fsioPins[LE_COMMAND_COUNT];
static void handleFsio(Engine *engine, int index) { static void handleFsio(Engine *engine, int index) {
if (boardConfiguration->fsioPins[index] == GPIO_UNASSIGNED) if (boardConfiguration->fsioPins[index] == GPIO_UNASSIGNED)
@ -154,8 +198,6 @@ static void handleFsio(Engine *engine, int index) {
bool_t isPwmMode = boardConfiguration->fsioFrequency[index] != 0; bool_t isPwmMode = boardConfiguration->fsioFrequency[index] != 0;
io_pin_e pin = (io_pin_e) ((int) GPIO_0 + index);
float fvalue = calc.getValue2(fsioLogics[index], engine); float fvalue = calc.getValue2(fsioLogics[index], engine);
engine->engineConfiguration2->fsioLastValue[index] = fvalue; engine->engineConfiguration2->fsioLastValue[index] = fvalue;
@ -163,23 +205,23 @@ static void handleFsio(Engine *engine, int index) {
fsioPwm[index].setSimplePwmDutyCycle(fvalue); fsioPwm[index].setSimplePwmDutyCycle(fvalue);
} else { } else {
int value = (int) fvalue; int value = (int) fvalue;
if (value != getOutputPinValue(pin)) { if (value != fsioPins[index].getLogicValue()) {
// scheduleMsg(&logger, "setting %s %s", getIo_pin_e(pin), boolToString(value)); // scheduleMsg(&logger, "setting %s %s", getIo_pin_e(pin), boolToString(value));
setOutputPinValue(pin, value); fsioPins[index].setValue(value);
} }
} }
} }
static void setPinState(io_pin_e ioPin, LEElement *element, Engine *engine) { static void setPinState(const char * msg, OutputPin *pin, LEElement *element, Engine *engine) {
if (element == NULL) { if (element == NULL) {
warning(OBD_PCM_Processor_Fault, "invalid expression for %s", getIo_pin_e(ioPin)); warning(OBD_PCM_Processor_Fault, "invalid expression for %s", msg);
} else { } else {
int value = calc.getValue2(element, engine); int value = calc.getValue2(element, engine);
if (value != getOutputPinValue(ioPin)) { if (value != pin->getLogicValue()) {
if (isRunningBenchTest()) if (isRunningBenchTest())
return; // let's not mess with bench testing return; // let's not mess with bench testing
scheduleMsg(&logger, "setting %s %s", getIo_pin_e(ioPin), boolToString(value)); scheduleMsg(&logger, "setting %s %s", msg, boolToString(value));
setOutputPinValue(ioPin, value); pin->setValue(value);
} }
} }
} }
@ -286,7 +328,7 @@ void runFsio(void) {
#if EFI_FUEL_PUMP #if EFI_FUEL_PUMP
if (boardConfiguration->fuelPumpPin != GPIO_UNASSIGNED && engineConfiguration->isFuelPumpEnabled) { if (boardConfiguration->fuelPumpPin != GPIO_UNASSIGNED && engineConfiguration->isFuelPumpEnabled) {
setPinState(FUEL_PUMP_RELAY, fuelPumpLogic, engine); setPinState("pump", &enginePins.fuelPumpRelay, fuelPumpLogic, engine);
} }
#endif #endif
@ -294,18 +336,21 @@ void runFsio(void) {
* main relay is always on if ECU is on, that's a good enough initial implementation * main relay is always on if ECU is on, that's a good enough initial implementation
*/ */
if (boardConfiguration->mainRelayPin != GPIO_UNASSIGNED) if (boardConfiguration->mainRelayPin != GPIO_UNASSIGNED)
setOutputPinValue(MAIN_RELAY, 1); enginePins.mainRelay.setValue(true);
enginePins.o2heater.setValue(engine->rpmCalculator.isRunning());
if (boardConfiguration->acRelayPin != GPIO_UNASSIGNED) { if (boardConfiguration->acRelayPin != GPIO_UNASSIGNED) {
setPinState(AC_RELAY, acRelayLogic, engine); setPinState("A/C", &enginePins.acRelay, acRelayLogic, engine);
} }
if (boardConfiguration->alternatorControlPin != GPIO_UNASSIGNED) { if (boardConfiguration->alternatorControlPin != GPIO_UNASSIGNED) {
setPinState(ALTERNATOR_SWITCH, alternatorLogic, engine); setPinState("alternator", &enginePins.alternatorField, alternatorLogic, engine);
} }
if (boardConfiguration->fanPin != GPIO_UNASSIGNED) { if (boardConfiguration->fanPin != GPIO_UNASSIGNED) {
// setPinState(FAN_RELAY, radiatorFanLogic, engine); setPinState("fan", &enginePins.fanRelay, radiatorFanLogic, engine);
} }
} }
@ -333,13 +378,13 @@ void initFsioImpl(Engine *engine) {
if (brainPin != GPIO_UNASSIGNED) { if (brainPin != GPIO_UNASSIGNED) {
//mySetPadMode2("user-defined", boardConfiguration->gpioPins[i], PAL_STM32_MODE_OUTPUT); //mySetPadMode2("user-defined", boardConfiguration->gpioPins[i], PAL_STM32_MODE_OUTPUT);
io_pin_e pin = (io_pin_e) ((int) GPIO_0 + i);
int frequency = boardConfiguration->fsioFrequency[i]; int frequency = boardConfiguration->fsioFrequency[i];
if (frequency == 0) { if (frequency == 0) {
outputPinRegisterExt2(getPinName(pin), &outputs[(int)pin], boardConfiguration->fsioPins[i], &defa); outputPinRegisterExt2(getGpioPinName(i), &fsioPins[i], boardConfiguration->fsioPins[i], &defa);
} else { } else {
startSimplePwmExt(&fsioPwm[i], "FSIO", brainPin, &outputs[(int)pin], frequency, 0.5f, applyPinState); startSimplePwmExt(&fsioPwm[i], "FSIO", brainPin, &fsioPins[i], frequency, 0.5f, applyPinState);
} }
} }
} }

45
firmware/controllers/engine_controller.cpp
View File

@ -132,26 +132,26 @@ static void updateErrorCodes(void) {
OBD_Engine_Coolant_Temperature_Circuit_Malfunction); OBD_Engine_Coolant_Temperature_Circuit_Malfunction);
} }
static void fanRelayControl(void) { //static void fanRelayControl(void) {
if (boardConfiguration->fanPin == GPIO_UNASSIGNED) // if (boardConfiguration->fanPin == GPIO_UNASSIGNED)
return; // return;
//
int isCurrentlyOn = getOutputPinValue(FAN_RELAY); // int isCurrentlyOn = getLogicPinValue(&en);
int newValue; // int newValue;
if (isCurrentlyOn) { // if (isCurrentlyOn) {
// if the fan is already on, we keep it on till the 'fanOff' temperature // // if the fan is already on, we keep it on till the 'fanOff' temperature
newValue = getCoolantTemperature(engine) > engineConfiguration->fanOffTemperature; // newValue = getCoolantTemperature(engine) > engineConfiguration->fanOffTemperature;
} else { // } else {
newValue = getCoolantTemperature(engine) > engineConfiguration->fanOnTemperature; // newValue = getCoolantTemperature(engine) > engineConfiguration->fanOnTemperature;
} // }
//
if (isCurrentlyOn != newValue) { // if (isCurrentlyOn != newValue) {
if (isRunningBenchTest()) // if (isRunningBenchTest())
return; // let's not mess with bench testing // return; // let's not mess with bench testing
scheduleMsg(&logger, "FAN relay: %s", newValue ? "ON" : "OFF"); // scheduleMsg(&logger, "FAN relay: %s", newValue ? "ON" : "OFF");
setOutputPinValue(FAN_RELAY, newValue); // setOutputPinValue(FAN_RELAY, newValue);
} // }
} //}
Overflow64Counter halTime; Overflow64Counter halTime;
@ -205,13 +205,8 @@ static void onEvenyGeneralMilliseconds(Engine *engine) {
updateErrorCodes(); updateErrorCodes();
// todo: migrate this to flex logic
fanRelayControl();
cylinderCleanupControl(engine); cylinderCleanupControl(engine);
setOutputPinValue(O2_HEATER, engine->rpmCalculator.isRunning());
// schedule next invocation // schedule next invocation
chVTSetAny(&everyMsTimer, boardConfiguration->generalPeriodicThreadPeriod * TICKS_IN_MS, chVTSetAny(&everyMsTimer, boardConfiguration->generalPeriodicThreadPeriod * TICKS_IN_MS,
(vtfunc_t) &onEvenyGeneralMilliseconds, engine); (vtfunc_t) &onEvenyGeneralMilliseconds, engine);

17
firmware/controllers/injector_central.cpp
View File

@ -43,6 +43,7 @@ static bool_t isRunningBench = false;
static int is_injector_enabled[MAX_INJECTOR_COUNT]; static int is_injector_enabled[MAX_INJECTOR_COUNT];
extern OutputPin outputs[IO_PIN_COUNT]; extern OutputPin outputs[IO_PIN_COUNT];
extern engine_pins_s enginePins;
void initIgnitionCentral(void) { void initIgnitionCentral(void) {
for (int i = 0; i < engineConfiguration->cylindersCount; i++) { for (int i = 0; i < engineConfiguration->cylindersCount; i++) {
@ -90,7 +91,7 @@ static void setInjectorEnabled(int id, int value) {
printStatus(); printStatus();
} }
static void runBench(brain_pin_e brainPin, io_pin_e pin, float delayMs, float onTimeMs, float offTimeMs, int count) { static void runBench(brain_pin_e brainPin, OutputPin *output, float delayMs, float onTimeMs, float offTimeMs, int count) {
scheduleMsg(&logger, "Running bench: ON_TIME=%f ms OFF_TIME=%fms Counter=%d", onTimeMs, offTimeMs, count); scheduleMsg(&logger, "Running bench: ON_TIME=%f ms OFF_TIME=%fms Counter=%d", onTimeMs, offTimeMs, count);
scheduleMsg(&logger, "output on %s", hwPortname(brainPin)); scheduleMsg(&logger, "output on %s", hwPortname(brainPin));
@ -99,8 +100,6 @@ static void runBench(brain_pin_e brainPin, io_pin_e pin, float delayMs, float on
chThdSleep(delaySt); chThdSleep(delaySt);
} }
OutputPin *output = &outputs[(int)pin];
isRunningBench = true; isRunningBench = true;
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
output->setValue(true); output->setValue(true);
@ -121,10 +120,10 @@ static float offTime;
static float delayMs; static float delayMs;
static int count; static int count;
static brain_pin_e brainPin; static brain_pin_e brainPin;
static io_pin_e pinX; static OutputPin* pinX;
static void pinbench(const char *delayStr, const char *onTimeStr, const char *offTimeStr, const char *countStr, static void pinbench(const char *delayStr, const char *onTimeStr, const char *offTimeStr, const char *countStr,
io_pin_e pinParam, brain_pin_e brainPinParam) { OutputPin* pinParam, brain_pin_e brainPinParam) {
delayMs = atoff(delayStr); delayMs = atoff(delayStr);
onTime = atoff(onTimeStr); onTime = atoff(onTimeStr);
offTime = atoff(offTimeStr); offTime = atoff(offTimeStr);
@ -148,12 +147,12 @@ static void fuelbench2(const char *delayStr, const char *indexStr, const char *
} }
brain_pin_e b = boardConfiguration->injectionPins[index - 1]; brain_pin_e b = boardConfiguration->injectionPins[index - 1];
io_pin_e p = (io_pin_e) ((int) INJECTOR_1_OUTPUT - 1 + index); io_pin_e p = (io_pin_e) ((int) INJECTOR_1_OUTPUT - 1 + index);
pinbench(delayStr, onTimeStr, offTimeStr, countStr, p, b); pinbench(delayStr, onTimeStr, offTimeStr, countStr, &outputs[(int)p], b);
} }
void fanBench(void) { void fanBench(void) {
brainPin = boardConfiguration->fanPin; brainPin = boardConfiguration->fanPin;
pinX = FAN_RELAY; pinX = &enginePins.fanRelay;
delayMs = 0; delayMs = 0;
onTime = 3000; onTime = 3000;
@ -177,7 +176,7 @@ void milBench(void) {
void fuelPumpBench(void) { void fuelPumpBench(void) {
brainPin = boardConfiguration->fuelPumpPin; brainPin = boardConfiguration->fuelPumpPin;
pinX = FUEL_PUMP_RELAY; pinX = &enginePins.fuelPumpRelay;
delayMs = 0; delayMs = 0;
onTime = 3000; onTime = 3000;
@ -204,7 +203,7 @@ static void sparkbench2(const char *delayStr, const char *indexStr, const char *
} }
brain_pin_e b = boardConfiguration->ignitionPins[index - 1]; brain_pin_e b = boardConfiguration->ignitionPins[index - 1];
io_pin_e p = (io_pin_e) ((int) SPARKOUT_1_OUTPUT - 1 + index); io_pin_e p = (io_pin_e) ((int) SPARKOUT_1_OUTPUT - 1 + index);
pinbench(delayStr, onTimeStr, offTimeStr, countStr, p, b); pinbench(delayStr, onTimeStr, offTimeStr, countStr, &outputs[(int)p], b);
} }
/** /**

66
firmware/controllers/lcd_controller.cpp
View File

@ -115,32 +115,32 @@ static const char* ignitionModeStr[] = { "1C", "IND", "WS" };
static const char* injectionModeStr[] = { "Sim", "Seq", "Bch" }; static const char* injectionModeStr[] = { "Sim", "Seq", "Bch" };
static const char* idleModeStr[] = { "I:A", "I:M" }; static const char* idleModeStr[] = { "I:A", "I:M" };
static const char *getPinShortName(io_pin_e pin) { //static const char *getPinShortName(io_pin_e pin) {
switch (pin) { // switch (pin) {
case ALTERNATOR_SWITCH: // case ALTERNATOR_SWITCH:
return "AL"; // return "AL";
case FUEL_PUMP_RELAY: // case FUEL_PUMP_RELAY:
return "FP"; // return "FP";
case FAN_RELAY: // case FAN_RELAY:
return "FN"; // return "FN";
case O2_HEATER: // case O2_HEATER:
return "O2H"; // return "O2H";
default: // default:
firmwareError("No short name for %d", (int) pin); // firmwareError("No short name for %d", (int) pin);
return ""; // return "";
} // }
} //}
char * appendPinStatus(char *buffer, io_pin_e pin) { //char * appendPinStatus(char *buffer, io_pin_e pin) {
char *ptr = appendStr(buffer, getPinShortName(pin)); // char *ptr = appendStr(buffer, getPinShortName(pin));
int state = getOutputPinValue(pin); // int state = getOutputPinValue(pin);
// todo: should we handle INITIAL_PIN_STATE? // // todo: should we handle INITIAL_PIN_STATE?
if (state) { // if (state) {
return appendStr(ptr, ":Y "); // return appendStr(ptr, ":Y ");
} else { // } else {
return appendStr(ptr, ":n "); // return appendStr(ptr, ":n ");
} // }
} //}
static char * prepareInfoLine(engine_configuration_s *engineConfiguration, char *buffer) { static char * prepareInfoLine(engine_configuration_s *engineConfiguration, char *buffer) {
char *ptr = buffer; char *ptr = buffer;
@ -158,14 +158,14 @@ static char * prepareInfoLine(engine_configuration_s *engineConfiguration, char
return ptr; return ptr;
} }
static char * prepareStatusLine(char *buffer) { //static char * prepareStatusLine(char *buffer) {
char *ptr = buffer; // char *ptr = buffer;
//
ptr = appendPinStatus(ptr, FUEL_PUMP_RELAY); // ptr = appendPinStatus(ptr, FUEL_PUMP_RELAY);
ptr = appendPinStatus(ptr, FAN_RELAY); // ptr = appendPinStatus(ptr, FAN_RELAY);
ptr = appendPinStatus(ptr, O2_HEATER); // ptr = appendPinStatus(ptr, O2_HEATER);
return ptr; // return ptr;
} //}
static char buffer[MAX_LCD_WIDTH + 4]; static char buffer[MAX_LCD_WIDTH + 4];
static char dateBuffer[30]; static char dateBuffer[30];

1
firmware/controllers/math/efitime.h
View File

@ -10,7 +10,6 @@
#ifndef EFITIME_H_ #ifndef EFITIME_H_
#define EFITIME_H_ #define EFITIME_H_
#include <stdint.h>
#include "efifeatures.h" #include "efifeatures.h"
#include "rusefi_types.h" #include "rusefi_types.h"

5
firmware/controllers/settings.cpp
View File

@ -37,6 +37,7 @@ static Logging logger;
static char LOGGING_BUFFER[1000]; static char LOGGING_BUFFER[1000];
extern int maxNesting; extern int maxNesting;
extern engine_pins_s enginePins;
/* /*
static void printIntArray(int array[], int size) { static void printIntArray(int array[], int size) {
@ -329,10 +330,10 @@ static void printTemperatureInfo(void) {
scheduleMsg(&logger, "IAT sensing error"); scheduleMsg(&logger, "IAT sensing error");
} }
scheduleMsg(&logger, "fan=%s @ %s", boolToString(getOutputPinValue(FAN_RELAY)), scheduleMsg(&logger, "fan=%s @ %s", boolToString(enginePins.fanRelay.getLogicValue()),
hwPortname(boardConfiguration->fanPin)); hwPortname(boardConfiguration->fanPin));
scheduleMsg(&logger, "A/C relay=%s @ %s", boolToString(getOutputPinValue(AC_RELAY)), scheduleMsg(&logger, "A/C relay=%s @ %s", boolToString(enginePins.acRelay.getLogicValue()),
hwPortname(boardConfiguration->acRelayPin)); hwPortname(boardConfiguration->acRelayPin));

44
firmware/controllers/system/efiGpio.cpp
View File

@ -14,10 +14,7 @@ pin_output_mode_e OUTPUT_MODE_DEFAULT = OM_DEFAULT;
// todo: clean this mess, this should become 'static'/private // todo: clean this mess, this should become 'static'/private
OutputPin outputs[IO_PIN_COUNT]; OutputPin outputs[IO_PIN_COUNT];
engine_pins_s enginePins;
int getOutputPinValue(io_pin_e pin) {
return getLogicPinValue(&outputs[pin]);
}
const char *namedPinsArray[NAMED_PIN_COUNT] = { "spa1", "spa2", "spa3", "spa4", "spa5", "spa6", "spa7", "spa8", const char *namedPinsArray[NAMED_PIN_COUNT] = { "spa1", "spa2", "spa3", "spa4", "spa5", "spa6", "spa7", "spa8",
"spa9", "spa10", "spa11", "spa12", "inj1", "inj2", "inj3", "inj4", "inj5", "inj6", "inj7", "inj8", "inj9", "spa9", "spa10", "spa11", "spa12", "inj1", "inj2", "inj3", "inj4", "inj5", "inj6", "inj7", "inj8", "inj9",
@ -52,38 +49,6 @@ const char *getPinName(io_pin_e io_pin) {
case INJECTOR_12_OUTPUT: case INJECTOR_12_OUTPUT:
return namedPinsArray[io_pin]; return namedPinsArray[io_pin];
case GPIO_0:
return "gpio0";
case GPIO_1:
return "gpio1";
case GPIO_2:
return "gpio2";
case GPIO_3:
return "gpio3";
case GPIO_4:
return "gpio4";
case GPIO_5:
return "gpio5";
case GPIO_6:
return "gpio6";
case GPIO_7:
return "gpio7";
case GPIO_8:
return "gpio8";
case GPIO_9:
return "gpio9";
case GPIO_10:
return "gpio10";
case GPIO_11:
return "gpio11";
case GPIO_12:
return "gpio12";
case GPIO_13:
return "gpio13";
case GPIO_14:
return "gpio14";
case GPIO_15:
return "gpio15";
default: default:
return "Pin needs name"; return "Pin needs name";
} }
@ -97,6 +62,10 @@ void OutputPin::setValue(int logicValue) {
doSetOutputPinValue2(this, logicValue); doSetOutputPinValue2(this, logicValue);
} }
bool_t OutputPin::getLogicValue() {
return currentLogicValue;
}
void OutputPin::setDefaultPinState(pin_output_mode_e *outputMode) { void OutputPin::setDefaultPinState(pin_output_mode_e *outputMode) {
#if EFI_GPIO #if EFI_GPIO
pin_output_mode_e mode = *outputMode; pin_output_mode_e mode = *outputMode;
@ -106,9 +75,6 @@ void OutputPin::setDefaultPinState(pin_output_mode_e *outputMode) {
setValue(false); // initial state setValue(false); // initial state
} }
extern uint32_t dbgStart;
extern uint32_t dbgDurr;
/** /**
* @brief Sets the value according to current electrical settings * @brief Sets the value according to current electrical settings
* *

17
firmware/controllers/system/efiGpio.h
View File

@ -23,6 +23,7 @@ public:
OutputPin(); OutputPin();
void setValue(int logicValue); void setValue(int logicValue);
void setDefaultPinState(pin_output_mode_e *defaultState); void setDefaultPinState(pin_output_mode_e *defaultState);
bool_t getLogicValue();
#if EFI_PROD_CODE #if EFI_PROD_CODE
GPIO_TypeDef *port; GPIO_TypeDef *port;
int pin; int pin;
@ -35,6 +36,15 @@ public:
int currentLogicValue; int currentLogicValue;
}; };
typedef struct {
OutputPin mainRelay;
OutputPin fanRelay;
OutputPin acRelay;
OutputPin fuelPumpRelay;
OutputPin o2heater;
OutputPin alternatorField;
} engine_pins_s;
/** /**
* it's a macro to be sure that stack is not used * it's a macro to be sure that stack is not used
* @return 0 for OM_DEFAULT and OM_OPENDRAIN * @return 0 for OM_DEFAULT and OM_OPENDRAIN
@ -49,8 +59,6 @@ public:
*/ */
#define getElectricalValue1(mode) ((mode) == OM_DEFAULT || (mode) == OM_OPENDRAIN) #define getElectricalValue1(mode) ((mode) == OM_DEFAULT || (mode) == OM_OPENDRAIN)
#define getLogicPinValue(outputPin) ((outputPin)->currentLogicValue)
/** /**
* Sets the value of the pin. On this layer the value is assigned as is, without any conversion. * Sets the value of the pin. On this layer the value is assigned as is, without any conversion.
*/ */
@ -59,7 +67,7 @@ public:
#define setPinValue(outputPin, electricalValue, logicValue) \ #define setPinValue(outputPin, electricalValue, logicValue) \
{ \ { \
if (getLogicPinValue(outputPin) != (logicValue)) { \ if ((outputPin)->currentLogicValue != (logicValue)) { \
palWritePad((outputPin)->port, (outputPin)->pin, (electricalValue)); \ palWritePad((outputPin)->port, (outputPin)->pin, (electricalValue)); \
(outputPin)->currentLogicValue = (logicValue); \ (outputPin)->currentLogicValue = (logicValue); \
} \ } \
@ -67,7 +75,7 @@ public:
#else /* EFI_PROD_CODE */ #else /* EFI_PROD_CODE */
#define setPinValue(outputPin, electricalValue, logicValue) \ #define setPinValue(outputPin, electricalValue, logicValue) \
{ \ { \
if (getLogicPinValue(outputPin) != (logicValue)) { \ if ((outputPin)->currentLogicValue != (logicValue)) { \
(outputPin)->currentLogicValue = (logicValue); \ (outputPin)->currentLogicValue = (logicValue); \
} \ } \
} }
@ -84,7 +92,6 @@ extern "C"
{ {
#endif /* __cplusplus */ #endif /* __cplusplus */
int getOutputPinValue(io_pin_e pin);
void setOutputPinValue(io_pin_e pin, int logicValue); void setOutputPinValue(io_pin_e pin, int logicValue);
const char *getPinName(io_pin_e io_pin); const char *getPinName(io_pin_e io_pin);

15
firmware/hw_layer/io_pins.cpp
View File

@ -28,6 +28,7 @@ static Logging logger;
static OutputPin sdCsPin; static OutputPin sdCsPin;
extern OutputPin outputs[IO_PIN_COUNT]; extern OutputPin outputs[IO_PIN_COUNT];
extern engine_pins_s enginePins;
#if defined(STM32F4XX) #if defined(STM32F4XX)
static GPIO_TypeDef *PORTS[] = { GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, GPIOF, GPIOG, GPIOH }; static GPIO_TypeDef *PORTS[] = { GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, GPIOF, GPIOG, GPIOH };
@ -103,7 +104,7 @@ static void getPinValue(const char *name) {
return; return;
} }
OutputPin * outputPin = &outputs[pin]; OutputPin * outputPin = &outputs[pin];
int value = getLogicPinValue(outputPin); int value = outputPin->getLogicValue();
scheduleMsg(&logger, "pin_value %s %d", name, value); scheduleMsg(&logger, "pin_value %s %d", name, value);
} }
@ -132,13 +133,13 @@ void initOutputPins(void) {
#endif #endif
// todo: should we move this code closer to the fuel pump logic? // todo: should we move this code closer to the fuel pump logic?
outputPinRegisterExt2("fuel pump relay", &outputs[(int)FUEL_PUMP_RELAY], boardConfiguration->fuelPumpPin, &DEFAULT_OUTPUT); outputPinRegisterExt2("fuel pump relay", &enginePins.fuelPumpRelay, boardConfiguration->fuelPumpPin, &DEFAULT_OUTPUT);
outputPinRegisterExt2("main relay", &outputs[(int)MAIN_RELAY], boardConfiguration->mainRelayPin, &boardConfiguration->mainRelayPinMode); outputPinRegisterExt2("main relay", &enginePins.mainRelay, boardConfiguration->mainRelayPin, &boardConfiguration->mainRelayPinMode);
outputPinRegisterExt2("fan relay", &outputs[(int)FAN_RELAY], boardConfiguration->fanPin, &DEFAULT_OUTPUT); outputPinRegisterExt2("fan relay", &enginePins.fanRelay, boardConfiguration->fanPin, &DEFAULT_OUTPUT);
outputPinRegisterExt2("o2 heater", &outputs[(int)O2_HEATER], boardConfiguration->o2heaterPin, &DEFAULT_OUTPUT); outputPinRegisterExt2("o2 heater", &enginePins.o2heater, boardConfiguration->o2heaterPin, &DEFAULT_OUTPUT);
outputPinRegisterExt2("A/C relay", &outputs[(int)AC_RELAY], boardConfiguration->acRelayPin, &boardConfiguration->acRelayPinMode); outputPinRegisterExt2("A/C relay", &enginePins.acRelay, boardConfiguration->acRelayPin, &boardConfiguration->acRelayPinMode);
// digit 1 // digit 1
/* /*
@ -180,7 +181,7 @@ static io_pin_e TO_BE_TURNED_OFF_ON_ERROR[] = { SPARKOUT_1_OUTPUT, SPARKOUT_2_OU
INJECTOR_1_OUTPUT, INJECTOR_2_OUTPUT, INJECTOR_3_OUTPUT, INJECTOR_4_OUTPUT, INJECTOR_5_OUTPUT, INJECTOR_1_OUTPUT, INJECTOR_2_OUTPUT, INJECTOR_3_OUTPUT, INJECTOR_4_OUTPUT, INJECTOR_5_OUTPUT,
INJECTOR_6_OUTPUT, INJECTOR_7_OUTPUT, INJECTOR_8_OUTPUT, INJECTOR_9_OUTPUT, INJECTOR_10_OUTPUT, INJECTOR_6_OUTPUT, INJECTOR_7_OUTPUT, INJECTOR_8_OUTPUT, INJECTOR_9_OUTPUT, INJECTOR_10_OUTPUT,
INJECTOR_11_OUTPUT, INJECTOR_12_OUTPUT, FUEL_PUMP_RELAY }; INJECTOR_11_OUTPUT, INJECTOR_12_OUTPUT };
/** /**
* This method is part of fatal error handling. * This method is part of fatal error handling.