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
void	handleQueryCommand (TsChannelBase *tsChannel, ts_response_format_e mode)
void	handleExecuteCommand (TsChannelBase *tsChannel, char *data, int incomingPacketSize)
void	handleWriteChunkCommand (TsChannelBase *tsChannel, uint16_t page, uint16_t offset, uint16_t count, void *content)
void	handleCrc32Check (TsChannelBase *tsChannel, uint16_t page, uint16_t offset, uint16_t count)
void	handlePageReadCommand (TsChannelBase *tsChannel, uint16_t page, 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 23 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,
                TS_TOTAL_OUTPUT_SIZE);
        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	page,
		uint16_t	offset,
		uint16_t	count
	)

Definition at line 350 of file tunerstudio.cpp.

                                                                                                           {
    tsState.crc32CheckCommandCounter++;
 
    // Ensure we are reading from in bounds
    if (validateOffsetCount(page, offset, count, tsChannel)) {
        tunerStudioError(tsChannel, "ERROR: CRC out of range");
        sendErrorCode(tsChannel, TS_RESPONSE_OUT_OF_RANGE);
        return;
    }
 
    const uint8_t* start = getWorkingPageAddr(tsChannel, page, offset);
    if (start == nullptr) {
        sendErrorCode(tsChannel, TS_RESPONSE_OUT_OF_RANGE, "ERROR: CRC invalid page");
        return;
    }
 
    uint32_t crc = SWAP_UINT32(crc32(start, count));
    tsChannel->sendResponse(TS_CRC, (const uint8_t *) &crc, 4);
    efiPrintf("TS <- Get CRC page %d offset %d count %d result %08x", page, 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 810 of file tunerstudio.cpp.

                                                                                              {
    ScopePerf perf(PE::TunerStudioHandleCrcCommand);
 
    char command = data[0];
    data++;
 
    const uint16_t* data16 = reinterpret_cast<uint16_t*>(data);
 
    // only few command have page argument, default page is 0
    uint16_t page = 0;
    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_OUTPUT_ALL_COMMAND:
        offset = 0;
        count = TS_TOTAL_OUTPUT_SIZE;
        // TS will not use this command until ochBlockSize is bigger than blockingFactor and prefer ochGetCommand :(
        cmdOutputChannels(tsChannel, offset, count);
        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_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_CHUNK_WRITE_COMMAND:
        /* command with page argument */
        page = data16[0];
        offset = data16[1];
        count = data16[2];
        handleWriteChunkCommand(tsChannel, page, offset, count, data + sizeof(TunerStudioPageRWChunkRequest));
        break;
    case TS_CRC_CHECK_COMMAND:
        /* command with page argument */
        page = data16[0];
        offset = data16[1];
        count = data16[2];
        handleCrc32Check(tsChannel, page, offset, count);
        break;
    case TS_BURN_COMMAND:
        /* command with page argument */
        page = data16[0];
        handleBurnCommand(tsChannel, page);
        break;
    case TS_READ_COMMAND:
        /* command with page argument */
        page = data16[0];
        offset = data16[1];
        count = data16[2];
        handlePageReadCommand(tsChannel, page, offset, count);
        break;
    case TS_TEST_COMMAND:
        [[fallthrough]];
    case 'T':
        handleTestCommand(tsChannel);
        break;
    case TS_GET_CONFIG_ERROR:
        handleGetConfigErorr(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_SIMULATOR || EFI_PROD_CODE
        //TODO: Why did we process `TS_IO_TEST_COMMAND` only in prod code? I've just turned it on for simulator as well, because
        //  I need test this functionality with simulator as well. We need to review the cases when we really need to turn off
        //  `TS_IO_TEST_COMMAND` processing. Do we really need guards below?
        {
            uint16_t subsystem = SWAP_UINT16(data16[0]);
            uint16_t index = SWAP_UINT16(data16[1]);
 
            executeTSCommand(subsystem, index);
        }
#endif /* EFI_SIMULATOR || 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 */
#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;
#else
    case TS_PERF_TRACE_BEGIN:
        criticalError("TS_PERF_TRACE not supported");
        break;
    case TS_PERF_TRACE_GET_BUFFER:
        criticalError("TS_PERF_TRACE_GET_BUFFER not supported");
        break;
#endif /* ENABLE_PERF_TRACE */
    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 799 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	page,
		uint16_t	offset,
		uint16_t	count
	)

Definition at line 418 of file tunerstudio.cpp.

                                                                                                                {
    tsState.readPageCommandsCounter++;
    efiPrintf("TS <- Page %d read chunk offset %d count %d", page, offset, count);
 
    if (validateOffsetCount(page, offset, count, tsChannel)) {
        tunerStudioError(tsChannel, "ERROR: RD out of range");
        sendErrorCode(tsChannel, TS_RESPONSE_OUT_OF_RANGE);
        return;
    }
 
    uint8_t* addr = getWorkingPageAddr(tsChannel, page, offset);
    if (page == TS_PAGE_SETTINGS) {
        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);
        }
    }
 
    if (addr == nullptr) {
        sendErrorCode(tsChannel, TS_RESPONSE_OUT_OF_RANGE, "ERROR: RD invalid page");
        return;
    }
 
    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:

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 576 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 563 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 372 of file tunerstudio.cpp.

                                                                     {
    tsState.readScatterCommandsCounter++;
 
    int totalResponseSize = 0;
    for (size_t i = 0; i < TS_SCATTER_OFFSETS_COUNT; i++) {
        uint16_t packed = tsChannel->page1.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 (size_t i = 0; i < TS_SCATTER_OFFSETS_COUNT; i++) {
        uint16_t packed = tsChannel->page1.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(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	page,
		uint16_t	offset,
		uint16_t	count,
		void *	content
	)

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

Definition at line 299 of file tunerstudio.cpp.

                       {
    tsState.writeChunkCommandCounter++;
 
    efiPrintf("TS -> Page %d write chunk offset %d count %d (output_count=%d)",
        page, offset, count, tsState.outputChannelsCommandCounter);
 
 
    if (validateOffsetCount(page, offset, count, tsChannel)) {
        tunerStudioError(tsChannel, "ERROR: WR out of range");
        sendErrorCode(tsChannel, TS_RESPONSE_OUT_OF_RANGE);
        return;
    }
 
    uint8_t * addr = getWorkingPageAddr(tsChannel, page, offset);
    if (addr == nullptr) {
        sendErrorCode(tsChannel, TS_RESPONSE_OUT_OF_RANGE, "ERROR: WR invalid page");
        return;
    }
 
    onCalibrationWrite(page, offset, count);
 
    // Special case
    if (page == TS_PAGE_SETTINGS) {
        if (isLockedFromUser()) {
            sendErrorCode(tsChannel, TS_RESPONSE_UNRECOGNIZED_COMMAND, "locked");
            return;
        }
 
        // Skip the write if a preset was just loaded - we don't want to overwrite it
        // [tag:popular_vehicle]
        if (!needToTriggerTsRefresh()) {
            memcpy(addr, content, count);
        } else {
            efiPrintf("Ignoring TS -> Page %d write chunk offset %d count %d (output_count=%d)",
                page,
                offset,
                count,
                tsState.outputChannelsCommandCounter
            );
        }
        // Force any board configuration options that humans shouldn't be able to change
        // huh, why is this NOT within above 'needToTriggerTsRefresh()' condition?
        call_board_override(custom_board_ConfigOverrides);
    } else {
        memcpy(addr, content, count);
    }
 
    sendOkResponse(tsChannel);
}

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 257 of file tunerstudio.cpp.

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

Referenced by cmdOutputChannels(), handleCrc32Check(), handleCrcCommand(), handlePageReadCommand(), handleWriteChunkCommand(), and sendErrorCode().

Here is the call graph for this function:

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