TunerStudio Class Reference

#include <tunerstudio_impl.h>

Inheritance diagram for TunerStudio:

Collaboration diagram for TunerStudio:

Public Member Functions
int	handleCrcCommand (TsChannelBase *tsChannel, char *data, int incomingPacketSize)
bool	handlePlainCommand (TsChannelBase *tsChannel, uint8_t command)
void	cmdOutputChannels (TsChannelBase *tsChannel, uint16_t offset, uint16_t count) override
	'Output' command sends out a snapshot of current values Gauges refresh More...
void	handleQueryCommand (TsChannelBase *tsChannel, ts_response_format_e mode)
void	handleExecuteCommand (TsChannelBase *tsChannel, char *data, int incomingPacketSize)
void	handlePageSelectCommand (TsChannelBase *tsChannel)
void	handleWriteChunkCommand (TsChannelBase *tsChannel, uint16_t offset, uint16_t count, void *content)
void	handleCrc32Check (TsChannelBase *tsChannel, uint16_t offset, uint16_t count)
void	handleWriteValueCommand (TsChannelBase *tsChannel, uint16_t offset, uint8_t value)
void	handlePageReadCommand (TsChannelBase *tsChannel, uint16_t offset, uint16_t count)
void	handleScatteredReadCommand (TsChannelBase *tsChannel)

Private Member Functions
void	sendErrorCode (TsChannelBase *tsChannel, uint8_t code, const char *msg="")

Additional Inherited Members

Detailed Description

Definition at line 23 of file tunerstudio_impl.h.

Member Function Documentation

cmdOutputChannels()

void TunerStudio::cmdOutputChannels ( TsChannelBase *  tsChannel, uint16_t  offset, uint16_t  count  )

overridevirtual

'Output' command sends out a snapshot of current values Gauges refresh

collect data from all models

Implements TunerStudioBase.

Definition at line 46 of file tunerstudio_commands.cpp.

                                                                                             {
    if (offset + count > TS_TOTAL_OUTPUT_SIZE) {
        efiPrintf("TS: Version Mismatch? Too much outputs requested offset=%d + count=%d/total=%d", offset, count,
                sizeof(TunerStudioOutputChannels));
        sendErrorCode(tsChannel, TS_RESPONSE_OUT_OF_RANGE, "cmd_size");
        return;
    }
 
    if (offset < BLOCKING_FACTOR) {
        engine->outputChannels.outputRequestPeriod = channelsRequestTimer.getElapsedUs();
        channelsRequestTimer.reset();
    }
 
    tsState.outputChannelsCommandCounter++;
    updateTunerStudioState();
    tsChannel->assertPacketSize(count, false);
    // this method is invoked too often to print any debug information
    uint8_t * scratchBuffer = (uint8_t *)tsChannel->scratchBuffer;
    /**
     * collect data from all models
     */
    copyRange(scratchBuffer + 3, getLiveDataFragments(), offset, count);
 
    tsChannel->crcAndWriteBuffer(TS_RESPONSE_OK, count);
}

Referenced by handleCrcCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

handleCrc32Check()

void TunerStudio::handleCrc32Check	(	TsChannelBase *	tsChannel,
		uint16_t	offset,
		uint16_t	count
	)

Definition at line 236 of file tunerstudio.cpp.

                                                                                            {
    tsState.crc32CheckCommandCounter++;
 
    // Ensure we are reading from in bounds
    if (validateOffsetCount(offset, count, tsChannel)) {
        return;
    }
 
#if EFI_TS_SCATTER
    /*
     * highSpeedOffsets is noMsqSave, but located on settings page,
     * zero highSpeedOffsets as TS expect all noMsqSave data to be zero during CRC matching
     * TODO:
     * Move highSpeedOffsets to separate page as it is done on MS devices
     * Zero highSpeedOffsets on start and reconnect
     * TODO:
     * Is Crc check command good sing of new TS session?
     * TODO:
     * Support settings pages!
     */
    memset(engineConfiguration->highSpeedOffsets, 0x00, sizeof(engineConfiguration->highSpeedOffsets));
#endif // EFI_TS_SCATTER
 
    const uint8_t* start = getWorkingPageAddr() + offset;
 
    uint32_t crc = SWAP_UINT32(crc32(start, count));
    tsChannel->sendResponse(TS_CRC, (const uint8_t *) &crc, 4);
    efiPrintf("TS <- Get CRC offset %d count %d result %08x", offset, count, (unsigned int)crc);
}

Referenced by handleCrcCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

handleCrcCommand()

int TunerStudio::handleCrcCommand	(	TsChannelBase *	tsChannel,
		char *	data,
		int	incomingPacketSize
	)

Definition at line 712 of file tunerstudio.cpp.

                                                                                              {
    ScopePerf perf(PE::TunerStudioHandleCrcCommand);
 
    char command = data[0];
    data++;
 
    const uint16_t* data16 = reinterpret_cast<uint16_t*>(data);
 
    uint16_t offset = 0;
    uint16_t count = 0;
 
    // command may not have offset field - keep safe default value
    // not used by .ini at the moment TODO actually use that version of the command in the .ini
    if (incomingPacketSize >= 3) {
        offset = data16[0];
    }
    // command may not have count/size filed - keep safe default value
    if (incomingPacketSize >= 5) {
        count = data16[1];
    }
 
    switch(command)
    {
    case TS_OUTPUT_COMMAND:
        if (incomingPacketSize == 1) {
            // Read command with no offset and size - read whole livedata
            count = TS_TOTAL_OUTPUT_SIZE;
        }
        cmdOutputChannels(tsChannel, offset, count);
        break;
    case TS_HELLO_COMMAND:
        tunerStudioDebug(tsChannel, "got Query command");
        handleQueryCommand(tsChannel, TS_CRC);
        break;
    case TS_GET_FIRMWARE_VERSION:
        handleGetVersion(tsChannel);
        break;
#if EFI_TEXT_LOGGING
    case TS_GET_TEXT:
        handleGetText(tsChannel);
        break;
#endif // EFI_TEXT_LOGGING
    case TS_EXECUTE:
        handleExecuteCommand(tsChannel, data, incomingPacketSize - 1);
        break;
    case TS_PAGE_COMMAND:
        handlePageSelectCommand(tsChannel);
        break;
    case TS_CHUNK_WRITE_COMMAND:
        handleWriteChunkCommand(tsChannel, offset, count, data + sizeof(TunerStudioWriteChunkRequest));
        break;
    case TS_SINGLE_WRITE_COMMAND:
        {
            uint8_t value = data[4];
            handleWriteValueCommand(tsChannel, offset, value);
        }
        break;
    case TS_GET_SCATTERED_GET_COMMAND:
#if EFI_TS_SCATTER
        handleScatteredReadCommand(tsChannel);
#else
    criticalError("Slow/wireless mode not supported");
#endif // EFI_TS_SCATTER
        break;
    case TS_CRC_CHECK_COMMAND:
        handleCrc32Check(tsChannel, offset, count);
        break;
    case TS_BURN_COMMAND:
        handleBurnCommand(tsChannel);
        break;
    case TS_READ_COMMAND:
        handlePageReadCommand(tsChannel, offset, count);
        break;
    case TS_TEST_COMMAND:
        [[fallthrough]];
    case 'T':
        handleTestCommand(tsChannel);
        break;
#if EFI_SIMULATOR
    case TS_SIMULATE_CAN:
        void handleWrapCan(TsChannelBase* tsChannel, char *data, int incomingPacketSize);
        handleWrapCan(tsChannel, data, incomingPacketSize - 1);
        break;
#endif // EFI_SIMULATOR
    case TS_IO_TEST_COMMAND:
        {
#if EFI_PROD_CODE
            uint16_t subsystem = SWAP_UINT16(data16[0]);
            uint16_t index = SWAP_UINT16(data16[1]);
 
            executeTSCommand(subsystem, index);
#endif /* EFI_PROD_CODE */
            sendOkResponse(tsChannel);
        }
        break;
#if EFI_TOOTH_LOGGER
    case TS_SET_LOGGER_SWITCH:
        switch(data[0]) {
        case TS_COMPOSITE_ENABLE:
            EnableToothLogger();
            break;
        case TS_COMPOSITE_DISABLE:
            DisableToothLogger();
            break;
        case TS_COMPOSITE_READ:
            {
                auto toothBuffer = GetToothLoggerBufferNonblocking();
 
                if (toothBuffer) {
                    tsChannel->sendResponse(TS_CRC, reinterpret_cast<const uint8_t*>(toothBuffer->buffer), toothBuffer->nextIdx * sizeof(composite_logger_s), true);
 
                    ReturnToothLoggerBuffer(toothBuffer);
                } else {
                    // TS asked for a tooth logger buffer, but we don't have one to give it.
                    sendErrorCode(tsChannel, TS_RESPONSE_OUT_OF_RANGE, DO_NOT_LOG);
                }
            }
            break;
#ifdef TRIGGER_SCOPE
        case TS_TRIGGER_SCOPE_ENABLE:
            triggerScopeEnable();
            break;
        case TS_TRIGGER_SCOPE_DISABLE:
            triggerScopeDisable();
            break;
        case TS_TRIGGER_SCOPE_READ:
            {
                const auto& buffer = triggerScopeGetBuffer();
 
                if (buffer) {
                    tsChannel->sendResponse(TS_CRC, buffer.get<uint8_t>(), buffer.size(), true);
                } else {
                    // TS asked for a tooth logger buffer, but we don't have one to give it.
                    sendErrorCode(tsChannel, TS_RESPONSE_OUT_OF_RANGE, DO_NOT_LOG);
                }
            }
            break;
#endif // TRIGGER_SCOPE
        default:
            // dunno what that was, send NAK
            return false;
        }
 
        sendOkResponse(tsChannel);
 
        break;
    case TS_GET_COMPOSITE_BUFFER_DONE_DIFFERENTLY:
        {
            EnableToothLoggerIfNotEnabled();
 
            auto toothBuffer = GetToothLoggerBufferNonblocking();
 
            if (toothBuffer) {
                tsChannel->sendResponse(TS_CRC, reinterpret_cast<const uint8_t*>(toothBuffer->buffer), toothBuffer->nextIdx * sizeof(composite_logger_s), true);
 
                ReturnToothLoggerBuffer(toothBuffer);
            } else {
                // TS asked for a tooth logger buffer, but we don't have one to give it.
                sendErrorCode(tsChannel, TS_RESPONSE_OUT_OF_RANGE, DO_NOT_LOG);
            }
        }
 
        break;
#else // EFI_TOOTH_LOGGER
    case TS_GET_COMPOSITE_BUFFER_DONE_DIFFERENTLY:
        sendErrorCode(tsChannel, TS_RESPONSE_OUT_OF_RANGE, DO_NOT_LOG);
        break;
#endif /* EFI_TOOTH_LOGGER */
#ifdef KNOCK_SPECTROGRAM
    case TS_KNOCK_SPECTROGRAM_ENABLE:
        knockSpectrogramEnable();
        sendOkResponse(tsChannel);
        break;
    case TS_KNOCK_SPECTROGRAM_DISABLE:
        knockSpectrogramDisable();
        sendOkResponse(tsChannel);
        break;
#endif /* KNOCK_SPECTROGRAM */
#if ENABLE_PERF_TRACE
    case TS_PERF_TRACE_BEGIN:
        perfTraceEnable();
        sendOkResponse(tsChannel);
        break;
    case TS_PERF_TRACE_GET_BUFFER:
        {
            auto trace = perfTraceGetBuffer();
            tsChannel->sendResponse(TS_CRC, trace.get<uint8_t>(), trace.size(), true);
        }
 
        break;
#endif /* ENABLE_PERF_TRACE */
    case TS_GET_CONFIG_ERROR: {
        const char* configError = getCriticalErrorMessage();
#if HW_CHECK_MODE
        // analog input errors are returned as firmware error in QC mode
        if (!hasFirmwareError()) {
            strcpy((char*)configError, "FACTORY_MODE_PLEASE_CONTACT_SUPPORT");
        }
#endif // HW_CHECK_MODE
        tsChannel->sendResponse(TS_CRC, reinterpret_cast<const uint8_t*>(configError), strlen(configError), true);
        break;
    }
    case TS_QUERY_BOOTLOADER: {
        uint8_t bldata = TS_QUERY_BOOTLOADER_NONE;
#if EFI_USE_OPENBLT
        bldata = TS_QUERY_BOOTLOADER_OPENBLT;
#endif
 
        tsChannel->sendResponse(TS_CRC, &bldata, 1, false);
        break;
    }
    default:
        sendErrorCode(tsChannel, TS_RESPONSE_UNRECOGNIZED_COMMAND, "unknown_command");
static char tsErrorBuff[80];
        chsnprintf(tsErrorBuff, sizeof(tsErrorBuff), "ERROR: ignoring unexpected command %d [%c]", command, command);
        tunerStudioError(tsChannel, tsErrorBuff);
        return false;
    }
 
    return true;
}

Referenced by tsProcessOne().

Here is the call graph for this function:

Here is the caller graph for this function:

handleExecuteCommand()

void TunerStudio::handleExecuteCommand	(	TsChannelBase *	tsChannel,
		char *	data,
		int	incomingPacketSize
	)

Definition at line 701 of file tunerstudio.cpp.

                                                                                                   {
    data[incomingPacketSize] = 0;
    char *trimmed = efiTrim(data);
#if EFI_SIMULATOR
            logMsg("execute [%s]\r\n", trimmed);
#endif // EFI_SIMULATOR
    (console_line_callback)(trimmed);
 
    tsChannel->writeCrcResponse(TS_RESPONSE_OK);
}

Referenced by handleCrcCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

handlePageReadCommand()

void TunerStudio::handlePageReadCommand	(	TsChannelBase *	tsChannel,
		uint16_t	offset,
		uint16_t	count
	)

Definition at line 339 of file tunerstudio.cpp.

                                                                                                 {
    tsState.readPageCommandsCounter++;
 
    if (rebootForPresetPending) {
        sendErrorCode(tsChannel, TS_RESPONSE_UNRECOGNIZED_COMMAND, "reboot");
        return;
    }
 
    efiPrintf("TS <- Read chunk offset %d count %d", offset, count);
 
    if (validateOffsetCount(offset, count, tsChannel)) {
        return;
    }
 
    uint8_t* addr;
    if (isLockedFromUser()) {
        // to have rusEFI console happy just send all zeros within a valid packet
        addr = (uint8_t*)&tsChannel->scratchBuffer + TS_PACKET_HEADER_SIZE;
        memset(addr, 0, count);
    } else {
        addr = getWorkingPageAddr() + offset;
    }
    tsChannel->sendResponse(TS_CRC, addr, count);
#if EFI_TUNER_STUDIO_VERBOSE
//  efiPrintf("Sending %d done", count);
#endif
}

Referenced by handleCrcCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

handlePageSelectCommand()

void TunerStudio::handlePageSelectCommand

(

TsChannelBase *

tsChannel

)

Definition at line 195 of file tunerstudio.cpp.

                                                                  {
    tsState.pageCommandCounter++;
 
    efiPrintf("TS -> Set page (no-op)");
 
    sendOkResponse(tsChannel);
}

Referenced by handleCrcCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

handlePlainCommand()

bool TunerStudio::handlePlainCommand	(	TsChannelBase *	tsChannel,
		uint8_t	command
	)

handle non CRC wrapped command

Returns

true if legacy command was processed, false otherwise

http://www.msextra.com/forums/viewtopic.php?f=122&t=48327 Response from TS support: This is an optional command * "The F command is used to find what ini. file needs to be loaded in TunerStudio to match the controller. If you are able to just make your firmware ignore the command that would work. Currently on some firmware versions the F command is not used and is just ignored by the firmware as a unknown command."

Definition at line 478 of file tunerstudio.cpp.

                                                                              {
    // Bail fast if guaranteed not to be a plain command
    if (command == 0) {
        return false;
    } else if (command == TS_HELLO_COMMAND || command == TS_QUERY_COMMAND) {
        // We interpret 'Q' as TS_HELLO_COMMAND, since TS uses hardcoded 'Q' during ECU detection (scan all serial ports)
        efiPrintf("Got naked Query command");
        handleQueryCommand(tsChannel, TS_PLAIN);
        return true;
    } else if (command == TS_TEST_COMMAND || command == 'T') {
        handleTestCommand(tsChannel);
        return true;
    } else if (command == TS_COMMAND_F) {
        /**
         * http://www.msextra.com/forums/viewtopic.php?f=122&t=48327
         * Response from TS support: This is an optional command         *
         * "The F command is used to find what ini. file needs to be loaded in TunerStudio to match the controller.
         * If you are able to just make your firmware ignore the command that would work.
         * Currently on some firmware versions the F command is not used and is just ignored by the firmware as a unknown command."
         */
 
        tunerStudioDebug(tsChannel, "not ignoring F");
        tsChannel->write((const uint8_t *)TS_PROTOCOL, strlen(TS_PROTOCOL));
        tsChannel->flush();
        return true;
    } else {
        // This wasn't a valid command
        return false;
    }
}

Referenced by tsProcessOne().

Here is the call graph for this function:

Here is the caller graph for this function:

handleQueryCommand()

void TunerStudio::handleQueryCommand	(	TsChannelBase *	tsChannel,
		ts_response_format_e	mode
	)

this command is part of protocol initialization

this command is part of protocol initialization

Query with CRC takes place while re-establishing connection Query without CRC takes place on TunerStudio startup

Definition at line 465 of file tunerstudio.cpp.

                                                                                        {
    tsState.queryCommandCounter++;
    const char *signature = getTsSignature();
 
    efiPrintf("TS <- Query signature: %s", signature);
    tsChannel->sendResponse(mode, (const uint8_t *)signature, strlen(signature) + 1);
}

Referenced by handleCrcCommand(), and handlePlainCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

handleScatteredReadCommand()

void TunerStudio::handleScatteredReadCommand

(

TsChannelBase *

tsChannel

)

Definition at line 267 of file tunerstudio.cpp.

                                                                     {
    int totalResponseSize = 0;
    for (int i = 0; i < HIGH_SPEED_COUNT; i++) {
        uint16_t packed = engineConfiguration->highSpeedOffsets[i];
        uint16_t type = packed >> 13;
 
        size_t size = type == 0 ? 0 : 1 << (type - 1);
#if EFI_SIMULATOR
//      printf("handleScatteredReadCommand 0x%x %d %d\n", packed, size, offset);
#endif /* EFI_SIMULATOR */
        totalResponseSize += size;
    }
#if EFI_SIMULATOR
//  printf("totalResponseSize %d\n", totalResponseSize);
#endif /* EFI_SIMULATOR */
 
 
    // Command part of CRC
    uint32_t crc = tsChannel->writePacketHeader(TS_RESPONSE_OK, totalResponseSize);
 
    uint8_t dataBuffer[8];
    for (int i = 0; i < HIGH_SPEED_COUNT; i++) {
        uint16_t packed = engineConfiguration->highSpeedOffsets[i];
        uint16_t type = packed >> 13;
        uint16_t offset = packed & 0x1FFF;
 
        if (type == 0)
            continue;
        size_t size = 1 << (type - 1);
 
        // write each data point and CRC incrementally
        copyRange(dataBuffer, getLiveDataFragments(), offset, size);
        tsChannel->write(dataBuffer, size, false);
        crc = crc32inc((void*)dataBuffer, crc, size);
    }
#if EFI_SIMULATOR
//  printf("CRC %x\n", crc);
#endif /* EFI_SIMULATOR */
    // now write total CRC
    *(uint32_t*)dataBuffer = SWAP_UINT32(crc);
    tsChannel->write(reinterpret_cast<uint8_t*>(dataBuffer), 4, true);
    tsChannel->flush();
}

Referenced by handleCrcCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

handleWriteChunkCommand()

void TunerStudio::handleWriteChunkCommand	(	TsChannelBase *	tsChannel,
		uint16_t	offset,
		uint16_t	count,
		void *	content
	)

This command is needed to make the whole transfer a bit faster

Note

See also handleWriteValueCommand

Definition at line 211 of file tunerstudio.cpp.

                       {
    tsState.writeChunkCommandCounter++;
    if (isLockedFromUser()) {
        sendErrorCode(tsChannel, TS_RESPONSE_UNRECOGNIZED_COMMAND, "locked");
        return;
    }
 
    efiPrintf("TS -> Write chunk offset %d count %d (output_count=%d)", offset, count, tsState.outputChannelsCommandCounter);
 
    if (validateOffsetCount(offset, count, tsChannel)) {
        return;
    }
 
    // Skip the write if a preset was just loaded - we don't want to overwrite it
    if (!rebootForPresetPending) {
        uint8_t * addr = (uint8_t *) (getWorkingPageAddr() + offset);
        memcpy(addr, content, count);
    }
    // Force any board configuration options that humans shouldn't be able to change
    setBoardConfigOverrides();
 
    sendOkResponse(tsChannel);
}

Referenced by handleCrcCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

handleWriteValueCommand()

void TunerStudio::handleWriteValueCommand	(	TsChannelBase *	tsChannel,
		uint16_t	offset,
		uint8_t	value
	)

'Write' command receives a single value at a given offset

Note

Writing values one by one is pretty slow

Definition at line 316 of file tunerstudio.cpp.

                                                                                                  {
    UNUSED(tsChannel);
 
    tsState.writeValueCommandCounter++;
    if (isLockedFromUser()) {
        sendErrorCode(tsChannel, TS_RESPONSE_UNRECOGNIZED_COMMAND, "locked");
        return;
    }
 
    efiPrintf("TS -> Write value offset %d value %d", offset, value);
 
    if (validateOffsetCount(offset, 1, tsChannel)) {
        return;
    }
 
    // Skip the write if a preset was just loaded - we don't want to overwrite it
    if (!rebootForPresetPending) {
        getWorkingPageAddr()[offset] = value;
    }
    // Force any board configuration options that humans shouldn't be able to change
    setBoardConfigOverrides();
}

Referenced by handleCrcCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

sendErrorCode()

void TunerStudio::sendErrorCode ( TsChannelBase *  tsChannel, uint8_t  code, const char *  msg = ""  )

private

Definition at line 191 of file tunerstudio.cpp.

                                                                                       {
    ::sendErrorCode(tsChannel, code, msg);
}

Referenced by cmdOutputChannels(), handleCrcCommand(), handlePageReadCommand(), handleWriteChunkCommand(), and handleWriteValueCommand().

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• console/binary/tunerstudio_impl.h
• console/binary/tunerstudio.cpp
• console/binary/tunerstudio_commands.cpp