/**
* @brief Sends all pending data to dev console
*/
void updateDevConsoleState(Engine *engine) {
if (!isConsoleReady()) {
return;
}
// looks like this is not needed anymore
// checkIfShouldHalt();
printPending();
/**
* this should go before the firmware error so that console can detect connection
*/
printSensors(&logger, false);
#if EFI_PROD_CODE || defined(__DOXYGEN__)
// todo: unify with simulator!
if (hasFirmwareError()) {
scheduleMsg(&logger, "FATAL error: %s", errorMessageBuffer);
warningEnabled = false;
scheduleLogging(&logger);
return;
}
#endif
#if (EFI_PROD_CODE && HAL_USE_ADC) || defined(__DOXYGEN__)
pokeAdcInputs();
#endif
if (!fullLog) {
return;
}
systime_t nowSeconds = getTimeNowSeconds();
printInfo(nowSeconds);
#if EFI_ENGINE_CONTROL || defined(__DOXYGEN__)
int currentCkpEventCounter = getCrankEventCounter();
if (prevCkpEventCounter == currentCkpEventCounter && timeOfPreviousReport == nowSeconds) {
return;
}
timeOfPreviousReport = nowSeconds;
prevCkpEventCounter = currentCkpEventCounter;
#else
chThdSleepMilliseconds(200);
#endif
printState();
#if EFI_WAVE_ANALYZER
printWave(&logger);
#endif
scheduleLogging(&logger);
}
void printFloatArray(char *prefix, float array[], int size) {
appendMsgPrefix(&logger);
appendPrintf(&logger, prefix);
for (int j = 0; j < size; j++)
appendPrintf(&logger, "%f ", array[j]);
appendMsgPostfix(&logger);
scheduleLogging(&logger);
}
static void printStatus(void) {
for (int id = 1; id <= engineConfiguration->cylindersCount; id++) {
resetLogging(&logger);
appendPrintf(&logger, "injector%d%s", id, DELIMETER);
appendPrintf(&logger, "%d", isInjectorEnabled(id));
appendPrintf(&logger, DELIMETER);
scheduleLogging(&logger);
}
}
// todo: remove this method, replace with 'scheduleMsg'
void scheduleIntValue(Logging *logging, const char *msg, int value) {
resetLogging(logging);
append(logging, msg);
append(logging, DELIMETER);
appendPrintf(logging, "%d", value);
append(logging, DELIMETER);
scheduleLogging(logging);
}
void scheduleMsg(Logging *logging, const char *fmt, ...) {
resetLogging(logging); // todo: is 'reset' really needed here?
appendMsgPrefix(logging);
va_list ap;
va_start(ap, fmt);
vappendPrintf(logging, fmt, ap);
va_end(ap);
appendMsgPostfix(logging);
scheduleLogging(logging);
}
void WaveChart::publish() {
appendPrintf(&logging, DELIMETER);
waveChartUsedSize = loggingSize(&logging);
#if DEBUG_WAVE
Logging *l = &chart->logging;
scheduleSimpleMsg(&debugLogging, "IT'S TIME", strlen(l->buffer));
#endif
bool isFullLog = getFullLog();
if (ENGINE(isEngineChartEnabled) && isFullLog) {
scheduleLogging(&logging);
}
}
void publishChart(WaveChart *chart) {
appendPrintf(&chart->logging, DELIMETER);
waveChartUsedSize = loggingSize(&chart->logging);
#if DEBUG_WAVE
Logging *l = &chart->logging;
scheduleSimpleMsg(&debugLogging, "IT'S TIME", strlen(l->buffer));
#endif
bool isFullLog = getFullLog();
if (isChartActive && isFullLog) {
scheduleLogging(&chart->logging);
}
}
/**
* @brief This function knows how to print a histogram_s summary
*/
void printHistogram(Logging *logging, histogram_s *histogram) {
int report[5];
int len = hsReport(histogram, report);
resetLogging(logging);
appendMsgPrefix(logging);
appendPrintf(logging, "histogram %s *", histogram->name);
for (int i = 0; i < len; i++)
appendPrintf(logging, "%d ", report[i]);
appendPrintf(logging, "*");
appendMsgPostfix(logging);
scheduleLogging(logging);
}
void turnPinLow(io_pin_e pin) {
// turn off the output
// todo: this XOR should go inside the setOutputPinValue method
setOutputPinValue(pin, false);
#if EFI_DEFAILED_LOGGING
systime_t after = hTimeNow();
debugInt(&signal->logging, "a_time", after - signal->hi_time);
scheduleLogging(&signal->logging);
#endif /* EFI_DEFAILED_LOGGING */
#if EFI_WAVE_CHART
addWaveChartEvent(getPinName(pin), WC_DOWN, "");
#endif /* EFI_WAVE_ANALYZER */
}
/**
* this whole method is executed under syslock so that we can have multiple threads use the same shared buffer
* in order to reduce memory usage
*/
void scheduleMsg(Logging *logging, const char *fmt, ...) {
efiAssertVoid(logging != NULL, "logging NULL");
int wasLocked = lockAnyContext();
resetLogging(logging); // todo: is 'reset' really needed here?
appendMsgPrefix(logging);
va_list ap;
va_start(ap, fmt);
vappendPrintf(logging, fmt, ap);
va_end(ap);
appendMsgPostfix(logging);
scheduleLogging(logging);
if (!wasLocked) {
unlockAnyContext();
}
}
void scAddData(float angle, float value) {
if (!initialized) {
return; // this is possible because of initialization sequence
}
if (engineConfiguration->sensorChartFrequency < 2) {
/**
* analog chart frequency cannot be 1 because of the way
* data flush is implemented, see below
*/
//todofirmwareError()
return;
}
if (getRevolutionCounter() % engineConfiguration->sensorChartFrequency != 0) {
/**
* We are here if we do NOT need to add an event to the analog chart
*/
if (pendingData) {
/**
* We are here if that's the first time we do not need to add
* data after we have added some data - meaning it's time to flush
*/
// message terminator
appendPrintf(&logging, DELIMETER);
// output pending data
#if EFI_PROD_CODE || defined(__DOXYGEN__)
if (getFullLog()) {
scheduleLogging(&logging);
}
#endif
pendingData = false;
}
return;
}
if (!pendingData) {
pendingData = true;
resetLogging(&logging);
// message header
appendPrintf(&logging, "analog_chart%s", DELIMETER);
}
if (remainingSize(&logging) > 100) {
appendPrintf(&logging, "%f|%f|", angle, value);
}
}
void printDateTime(void) {
static time_t unix_time;
struct tm timp;
unix_time = rtcGetTimeUnixSec(&RTCD1);
if (unix_time == -1) {
scheduleMsg(&logger, "incorrect time in RTC cell");
} else {
scheduleMsg(&logger, "%D - unix time", unix_time);
rtcGetTimeTm(&RTCD1, &timp);
appendMsgPrefix(&logger);
appendPrintf(&logger, "Current RTC time in GMT is: %04u-%02u-%02u %02u:%02u:%02u", timp.tm_year + 1900, timp.tm_mon + 1, timp.tm_mday, timp.tm_hour,
timp.tm_min, timp.tm_sec);
appendMsgPostfix(&logger);
scheduleLogging(&logger);
}
}
/**
* @brief This function knows how to print a histogram_s summary
*/
void printHistogram(Logging *logging, histogram_s *histogram) {
#if EFI_HISTOGRAMS && ! EFI_UNIT_TEST
int report[5];
int len = hsReport(histogram, report);
resetLogging(logging);
appendMsgPrefix(logging);
appendPrintf(logging, "histogram %s *", histogram->name);
for (int i = 0; i < len; i++)
appendPrintf(logging, "%d ", report[i]);
appendPrintf(logging, "*");
appendMsgPostfix(logging);
scheduleLogging(logging);
#else
UNUSED(logging);
UNUSED(histogram);
#endif /* EFI_HISTOGRAMS */
}
static void printFullAdcReport(void) {
for (int index = 0; index < EFI_ADC_SLOW_CHANNELS_COUNT; index++) {
appendMsgPrefix(&logger);
int hwIndex = getAdcHardwareIndexByInternalIndex(index);
GPIO_TypeDef* port = getAdcChannelPort(hwIndex);
int pin = getAdcChannelPin(hwIndex);
int adcValue = getAdcValueByIndex(index);
appendPrintf(&logger, " ch%d %s%d", index, portname(port), pin);
appendPrintf(&logger, " ADC%d 12bit=%d", hwIndex, adcValue);
float volts = adcToVolts(adcValue);
appendPrintf(&logger, " v=%f", volts);
appendMsgPostfix(&logger);
scheduleLogging(&logger);
}
}
void turnPinLow(NamedOutputPin *output) {
efiAssertVoid(output!=NULL, "NULL turnPinLow");
// turn off the output
doSetOutputPinValue2(output, false);
#if EFI_DEFAILED_LOGGING || defined(__DOXYGEN__)
systime_t after = hTimeNow();
debugInt(&signal->logging, "a_time", after - signal->hi_time);
scheduleLogging(&signal->logging);
#endif /* EFI_DEFAILED_LOGGING */
#if EFI_ENGINE_SNIFFER || defined(__DOXYGEN__)
if (ENGINE(isEngineChartEnabled)) {
// this is a performance optimization - array index is cheaper then invoking a method with 'switch'
const char *pinName = output->name;
addEngineSniffferEvent(pinName, WC_DOWN);
}
#endif /* EFI_ENGINE_SNIFFER */
}
static void printFullAdcReport(void) {
scheduleMsg(&logger, "fast %d slow %d", fastAdc.conversionCount, slowAdc.conversionCount);
for (int index = 0; index < slowAdc.size(); index++) {
appendMsgPrefix(&logger);
adc_channel_e hwIndex = slowAdc.getAdcHardwareIndexByInternalIndex(index);
GPIO_TypeDef* port = getAdcChannelPort(hwIndex);
int pin = getAdcChannelPin(hwIndex);
int adcValue = slowAdc.getAdcValueByIndex(index);
appendPrintf(&logger, " ch%d %s%d", index, portname(port), pin);
appendPrintf(&logger, " ADC%d 12bit=%d", hwIndex, adcValue);
float volts = adcToVolts(adcValue);
appendPrintf(&logger, " v=%f", volts);
appendMsgPostfix(&logger);
scheduleLogging(&logger);
}
}
void turnPinLow(NamedOutputPin *output) {
efiAssertVoid(output!=NULL, "NULL turnPinLow");
#if EFI_GPIO
// turn off the output
doSetOutputPinValue2(output, false);
#endif
#if EFI_DEFAILED_LOGGING
systime_t after = hTimeNow();
debugInt(&signal->logging, "a_time", after - signal->hi_time);
scheduleLogging(&signal->logging);
#endif /* EFI_DEFAILED_LOGGING */
#if EFI_WAVE_CHART
if (CONFIG(isDigitalChartEnabled)) {
// this is a performance optimization - array index is cheaper then invoking a method with 'switch'
const char *pinName = output->name;
addWaveChartEvent(pinName, WC_DOWN);
}
#endif /* EFI_WAVE_ANALYZER */
}
static void printFullAdcReport(Logging *logger) {
scheduleMsg(logger, "fast %d slow %d", fastAdc.conversionCount, slowAdc.conversionCount);
for (int index = 0; index < slowAdc.size(); index++) {
appendMsgPrefix(logger);
adc_channel_e hwIndex = slowAdc.getAdcHardwareIndexByInternalIndex(index);
if(hwIndex != EFI_ADC_NONE && hwIndex != EFI_ADC_ERROR)
{
ioportid_t port = getAdcChannelPort("print", hwIndex);
int pin = getAdcChannelPin(hwIndex);
int adcValue = slowAdc.getAdcValueByIndex(index);
appendPrintf(logger, " ch%d %s%d", index, portname(port), pin);
appendPrintf(logger, " ADC%d 12bit=%d", hwIndex, adcValue);
float volts = adcToVolts(adcValue);
appendPrintf(logger, " v=%.2f", volts);
appendMsgPostfix(logger);
scheduleLogging(logger);
}
}
}
void idleDebug(char *msg, int value) {
printMsg(&logger, "%s%d", msg, value);
scheduleLogging(&logger);
}
