tunerstudio.cpp File Reference

Detailed Description

Binary protocol implementation.

This implementation would not happen without the documentation provided by Jon Zeeff (jon@z.nosp@m.eeff.nosp@m..com)

Integration with EFI Analytics Tuner Studio software

Tuner Studio has a really simple protocol, a minimal implementation capable of displaying current engine state on the gauges would require only two commands: queryCommand and ochGetCommand

queryCommand: Communication initialization command. TunerStudio sends a single byte H ECU response: One of the known ECU id strings.

ochGetCommand: Request for output channels state.TunerStudio sends a single byte O ECU response: A snapshot of output channels as described in [OutputChannels] section of the .ini file The length of this block is 'ochBlockSize' property of the .ini file

These two commands are enough to get working gauges. In order to start configuring the ECU using tuner studio, three more commands should be implemented:

Date

Oct 22, 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/.

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/.

Definition in file tunerstudio.cpp.

Functions
static void	printErrorCounters ()
static void	printScatterList ()
static void	resetTs ()
static void	printTsStats (void)
static void	setTsSpeed (int value)
void	tunerStudioDebug (TsChannelBase *tsChannel, const char *msg)
uint8_t *	getWorkingPageAddr ()
static void	sendOkResponse (TsChannelBase *tsChannel)
void	sendErrorCode (TsChannelBase *tsChannel, uint8_t code, const char *msg)
bool	validateOffsetCount (size_t offset, size_t count, TsChannelBase *tsChannel)
void	requestBurn ()
static void	handleBurnCommand (TsChannelBase *tsChannel)
static bool	isKnownCommand (char command)
static void	handleTestCommand (TsChannelBase *tsChannel)
static int	tsProcessOne (TsChannelBase *tsChannel)
void	tunerStudioError (TsChannelBase *tsChannel, const char *msg)
static void	handleGetVersion (TsChannelBase *tsChannel)
static void	handleGetText (TsChannelBase *tsChannel)
void	startTunerStudioConnectivity (void)

Variables
bool	rebootForPresetPending
TunerStudio	tsInstance
tunerstudio_counters_s	tsState
CommandHandler	console_line_callback

Function Documentation

getWorkingPageAddr()

uint8_t* getWorkingPageAddr

(

)

Definition at line 154 of file tunerstudio.cpp.

                              {
    return (uint8_t*)engineConfiguration;
}

Referenced by TunerStudio::handleCrc32Check(), TunerStudio::handlePageReadCommand(), TunerStudio::handleWriteChunkCommand(), and TunerStudio::handleWriteValueCommand().

Here is the caller graph for this function:

handleBurnCommand()

static void handleBurnCommand ( TsChannelBase *  tsChannel )

static

'Burn' command is a command to commit the changes

Definition at line 383 of file tunerstudio.cpp.

                                                        {
    Timer t;
    t.reset();
 
    tsState.burnCommandCounter++;
 
    efiPrintf("TS -> Burn");
    validateConfigOnStartUpOrBurn();
 
    // Skip the burn if a preset was just loaded - we don't want to overwrite it
    if (!rebootForPresetPending) {
        requestBurn();
    }
 
    tsChannel->writeCrcResponse(TS_RESPONSE_BURN_OK);
    efiPrintf("Burned in %.1fms", t.getElapsedSeconds() * 1e3);
}

Referenced by TunerStudio::handleCrcCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

handleGetText()

static void handleGetText ( TsChannelBase *  tsChannel )

static

Definition at line 683 of file tunerstudio.cpp.

                                                    {
    tsState.textCommandCounter++;
 
    printOverallStatus();
 
    size_t outputSize;
    const char* output = swapOutputBuffers(&outputSize);
#if EFI_SIMULATOR
            logMsg("get test sending [%d]\r\n", outputSize);
#endif
 
    tsChannel->writeCrcPacket(TS_RESPONSE_OK, reinterpret_cast<const uint8_t*>(output), outputSize, true);
#if EFI_SIMULATOR
            logMsg("sent [%d]\r\n", outputSize);
#endif // EFI_SIMULATOR
}

Referenced by TunerStudio::handleCrcCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

handleGetVersion()

static void handleGetVersion ( TsChannelBase *  tsChannel )

static

Definition at line 676 of file tunerstudio.cpp.

                                                       {
    char versionBuffer[32];
    chsnprintf(versionBuffer, sizeof(versionBuffer), "%s v%d@%u", FRONTEND_TITLE_BAR_NAME, getRusEfiVersion(), SIGNATURE_HASH);
    tsChannel->sendResponse(TS_CRC, (const uint8_t *) versionBuffer, strlen(versionBuffer) + 1);
}

Referenced by TunerStudio::handleCrcCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

handleTestCommand()

static void handleTestCommand ( TsChannelBase *  tsChannel )

static

rusEfi own test command

this is NOT a standard TunerStudio command, this is my own extension of the protocol to simplify troubleshooting

Definition at line 432 of file tunerstudio.cpp.

                                                        {
    tsState.testCommandCounter++;
    char testOutputBuffer[64];
    /**
     * this is NOT a standard TunerStudio command, this is my own
     * extension of the protocol to simplify troubleshooting
     */
    tunerStudioDebug(tsChannel, "got T (Test)");
    tsChannel->write((const uint8_t*)QUOTE(SIGNATURE_HASH), sizeof(QUOTE(SIGNATURE_HASH)));
 
    chsnprintf(testOutputBuffer, sizeof(testOutputBuffer), " %d %d", engine->engineState.warnings.lastErrorCode, tsState.testCommandCounter);
    tsChannel->write((const uint8_t*)testOutputBuffer, strlen(testOutputBuffer));
 
    chsnprintf(testOutputBuffer, sizeof(testOutputBuffer), " uptime=%ds ", (int)getTimeNowS());
    tsChannel->write((const uint8_t*)testOutputBuffer, strlen(testOutputBuffer));
 
    chsnprintf(testOutputBuffer, sizeof(testOutputBuffer),  __DATE__ " %s\r\n", PROTOCOL_TEST_RESPONSE_TAG);
    tsChannel->write((const uint8_t*)testOutputBuffer, strlen(testOutputBuffer));
 
    if (hasFirmwareError()) {
        const char* error = getCriticalErrorMessage();
        chsnprintf(testOutputBuffer, sizeof(testOutputBuffer), "error=%s\r\n", error);
        tsChannel->write((const uint8_t*)testOutputBuffer, strlen(testOutputBuffer));
    }
    tsChannel->flush();
}

Referenced by TunerStudio::handleCrcCommand(), and TunerStudio::handlePlainCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

isKnownCommand()

static bool isKnownCommand ( char  command )

static

Definition at line 403 of file tunerstudio.cpp.

                                         {
    return command == TS_HELLO_COMMAND || command == TS_READ_COMMAND || command == TS_OUTPUT_COMMAND
            || command == TS_PAGE_COMMAND || command == TS_BURN_COMMAND || command == TS_SINGLE_WRITE_COMMAND
            || command == TS_CHUNK_WRITE_COMMAND || command == TS_EXECUTE
            || command == TS_IO_TEST_COMMAND
#if EFI_SIMULATOR
            || command == TS_SIMULATE_CAN
#endif // EFI_SIMULATOR
#if EFI_TS_SCATTER
            || command == TS_GET_SCATTERED_GET_COMMAND
#endif
            || command == TS_SET_LOGGER_SWITCH
            || command == TS_GET_COMPOSITE_BUFFER_DONE_DIFFERENTLY
            || command == TS_GET_TEXT
            || command == TS_CRC_CHECK_COMMAND
            || command == TS_GET_FIRMWARE_VERSION
#ifdef KNOCK_SPECTROGRAM
            || command == TS_KNOCK_SPECTROGRAM_ENABLE
            || command == TS_KNOCK_SPECTROGRAM_DISABLE
#endif
            || command == TS_PERF_TRACE_BEGIN
            || command == TS_PERF_TRACE_GET_BUFFER
            || command == TS_GET_CONFIG_ERROR
            || command == TS_QUERY_BOOTLOADER;
}

Referenced by tsProcessOne().

Here is the caller graph for this function:

printErrorCounters()

static void printErrorCounters ( )

static

Definition at line 93 of file tunerstudio.cpp.

                                 {
    efiPrintf("TunerStudio size=%d / total=%d / errors=%d / H=%d / O=%d / P=%d / B=%d",
            sizeof(engine->outputChannels), tsState.totalCounter, tsState.errorCounter, tsState.queryCommandCounter,
            tsState.outputChannelsCommandCounter, tsState.readPageCommandsCounter, tsState.burnCommandCounter);
    efiPrintf("TunerStudio W=%d / C=%d / P=%d", tsState.writeValueCommandCounter,
            tsState.writeChunkCommandCounter, tsState.pageCommandCounter);
    efiPrintf("TunerStudio errors: underrun=%d / overrun=%d / crc=%d / unrecognized=%d / outofrange=%d / other=%d",
            tsState.errorUnderrunCounter, tsState.errorOverrunCounter, tsState.errorCrcCounter,
            tsState.errorUnrecognizedCommand, tsState.errorOutOfRange, tsState.errorOther);
}

Referenced by printTsStats(), and tunerStudioError().

Here is the caller graph for this function:

printScatterList()

static void printScatterList ( )

static

Definition at line 104 of file tunerstudio.cpp.

                               {
    efiPrintf("Scatter list (global)");
    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);
 
        efiPrintf("%02d offset 0x%04x size %d", i, offset, size);
    }
}

Referenced by printTsStats().

Here is the caller graph for this function:

printTsStats()

static void printTsStats ( void  )

static

Definition at line 128 of file tunerstudio.cpp.

                               {
#ifdef EFI_CONSOLE_RX_BRAIN_PIN
    efiPrintf("Primary UART RX %s", hwPortname(EFI_CONSOLE_RX_BRAIN_PIN));
    efiPrintf("Primary UART TX %s", hwPortname(EFI_CONSOLE_TX_BRAIN_PIN));
#endif /* EFI_CONSOLE_RX_BRAIN_PIN */
 
#if EFI_USB_SERIAL
    printUsbConnectorStats();
#endif // EFI_USB_SERIAL
 
    printErrorCounters();
 
    printScatterList();
}

Referenced by setTsSpeed(), and startTunerStudioConnectivity().

Here is the call graph for this function:

Here is the caller graph for this function:

requestBurn()

void requestBurn

(

)

Definition at line 368 of file tunerstudio.cpp.

                   {
#if !EFI_UNIT_TEST
    onBurnRequest();
 
#if EFI_CONFIGURATION_STORAGE
    setNeedToWriteConfiguration();
#endif /* EFI_CONFIGURATION_STORAGE */
#endif // !EFI_UNIT_TEST
}

Referenced by configureRusefiLuaHooks(), handleBurnCommand(), initFlash(), and unlockEcu().

Here is the call graph for this function:

Here is the caller graph for this function:

resetTs()

static void resetTs ( )

static

Definition at line 124 of file tunerstudio.cpp.

                      {
    memset(&tsState, 0, sizeof(tsState));
}

Referenced by startTunerStudioConnectivity().

Here is the caller graph for this function:

sendErrorCode()

void sendErrorCode	(	TsChannelBase *	tsChannel,
		uint8_t	code,
		const char *	msg
	)

Definition at line 162 of file tunerstudio.cpp.

                                                                            {
//TODO uncomment once I have test it myself  if (msg != DO_NOT_LOG) {
//    efiPrintf("TS <- Err: %d [%s]", code, msg);
//  }
 
    switch (code) {
    case TS_RESPONSE_UNDERRUN:
        tsState.errorUnderrunCounter++;
        break;
    case TS_RESPONSE_OVERRUN:
        tsState.errorOverrunCounter++;
        break;
    case TS_RESPONSE_CRC_FAILURE:
        tsState.errorCrcCounter++;
        break;
    case TS_RESPONSE_UNRECOGNIZED_COMMAND:
        tsState.errorUnrecognizedCommand++;
        break;
    case TS_RESPONSE_OUT_OF_RANGE:
        tsState.errorOutOfRange++;
        break;
    default:
        tsState.errorOther++;
        break;
    }
 
    tsChannel->writeCrcResponse(code);
}

Referenced by tsProcessOne(), and validateOffsetCount().

Here is the call graph for this function:

Here is the caller graph for this function:

sendOkResponse()

static void sendOkResponse ( TsChannelBase *  tsChannel )

static

Definition at line 158 of file tunerstudio.cpp.

                                                     {
    tsChannel->sendResponse(TS_CRC, nullptr, 0);
}

Referenced by TunerStudio::handleCrcCommand(), TunerStudio::handlePageSelectCommand(), and TunerStudio::handleWriteChunkCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

setTsSpeed()

static void setTsSpeed ( int  value )

static

Definition at line 143 of file tunerstudio.cpp.

                                  {
    engineConfiguration->tunerStudioSerialSpeed = value;
    printTsStats();
}

Referenced by startTunerStudioConnectivity().

Here is the call graph for this function:

Here is the caller graph for this function:

startTunerStudioConnectivity()

void startTunerStudioConnectivity

(

void

)

Definition at line 936 of file tunerstudio.cpp.

                                        {
    // Assert tune & output channel struct sizes
    static_assert(sizeof(persistent_config_s) == TOTAL_CONFIG_SIZE, "TS datapage size mismatch");
// useful trick if you need to know how far off is the static_assert
//  char (*__kaboom)[sizeof(persistent_config_s)] = 1;
// another useful trick
//  static_assert(offsetof (engine_configuration_s,HD44780_e) == 700);
 
    memset(&tsState, 0, sizeof(tsState));
 
    addConsoleAction("tsinfo", printTsStats);
    addConsoleAction("reset_ts", resetTs);
    addConsoleActionI("set_ts_speed", setTsSpeed);
 
#if EFI_BLUETOOTH_SETUP
    // module initialization start (it waits for disconnect and then communicates to the module)
    // Usage:   "bluetooth_hc06 <baud> <name> <pincode>"
    // Example: "bluetooth_hc06 38400 rusefi 1234"
    // bluetooth_jdy 115200 alphax 1234
    addConsoleActionSSS("bluetooth_hc05", [](const char *baudRate, const char *name, const char *pinCode) {
        bluetoothStart(BLUETOOTH_HC_05, baudRate, name, pinCode);
    });
    addConsoleActionSSS("bluetooth_hc06", [](const char *baudRate, const char *name, const char *pinCode) {
        bluetoothStart(BLUETOOTH_HC_06, baudRate, name, pinCode);
    });
    addConsoleActionSSS("bluetooth_bk", [](const char *baudRate, const char *name, const char *pinCode) {
        bluetoothStart(BLUETOOTH_BK3231, baudRate, name, pinCode);
    });
    addConsoleActionSSS("bluetooth_jdy", [](const char *baudRate, const char *name, const char *pinCode) {
        bluetoothStart(BLUETOOTH_JDY_3x, baudRate, name, pinCode);
    });
  addConsoleActionSSS("bluetooth_jdy31", [](const char *baudRate, const char *name, const char *pinCode) {
        bluetoothStart(BLUETOOTH_JDY_31, baudRate, name, pinCode);
    });
#endif /* EFI_BLUETOOTH_SETUP */
}

Referenced by runRusEfi().

Here is the call graph for this function:

Here is the caller graph for this function:

tsProcessOne()

static int tsProcessOne ( TsChannelBase *  tsChannel )

static

Definition at line 511 of file tunerstudio.cpp.

                                                  {
    assertStack("communication", ObdCode::STACK_USAGE_COMMUNICATION, EXPECTED_REMAINING_STACK, -1);
 
    if (!tsChannel->isReady()) {
        chThdSleepMilliseconds(10);
        return -1;
    }
 
    tsState.totalCounter++;
 
    uint8_t firstByte;
    size_t received = tsChannel->readTimeout(&firstByte, 1, TS_COMMUNICATION_TIMEOUT);
#if EFI_SIMULATOR
        logMsg("received %d\r\n", received);
#endif // EFI_SIMULATOR
 
    if (received != 1) {
//          tunerStudioError("ERROR: no command");
#if EFI_BLUETOOTH_SETUP
        if (tsChannel == getBluetoothChannel()) {
            // no data in a whole second means time to disconnect BT
            // assume there's connection loss and notify the bluetooth init code
            bluetoothSoftwareDisconnectNotify(getBluetoothChannel());
        }
#endif  /* EFI_BLUETOOTH_SETUP */
        tsChannel->in_sync = false;
        return -1;
    }
 
    if (tsInstance.handlePlainCommand(tsChannel, firstByte)) {
        return 0;
    }
 
    uint8_t secondByte;
    /* second byte should be received within minimal delay */
    received = tsChannel->readTimeout(&secondByte, 1, TS_COMMUNICATION_TIMEOUT_SHORT);
    if (received != 1) {
        tunerStudioError(tsChannel, "TS: ERROR: no second byte");
        tsChannel->in_sync = false;
        return -1;
    }
 
    uint16_t incomingPacketSize = firstByte << 8 | secondByte;
    size_t expectedSize = incomingPacketSize + TS_PACKET_TAIL_SIZE;
 
    if ((incomingPacketSize == 0) || (expectedSize > sizeof(tsChannel->scratchBuffer))) {
        if (tsChannel->in_sync) {
            efiPrintf("process_ts: channel=%s invalid size: %d", tsChannel->name, incomingPacketSize);
            tunerStudioError(tsChannel, "process_ts: ERROR: packet size");
            /* send error only if previously we were in sync */
            sendErrorCode(tsChannel, TS_RESPONSE_OUT_OF_RANGE, "invalid size");
        }
        tsChannel->in_sync = false;
        return -1;
    }
 
    char command;
    if (tsChannel->in_sync) {
        /* we are in sync state, packet size should be correct so lets receive full packet and then check if command is supported
         * otherwise (if abort reception in middle of packet) it will break synchronization and cause error on next packet */
        received = tsChannel->readTimeout((uint8_t*)(tsChannel->scratchBuffer), expectedSize, TS_COMMUNICATION_TIMEOUT);
        command = tsChannel->scratchBuffer[0];
 
        if (received != expectedSize) {
            /* print and send error as we were in sync */
            efiPrintf("Got only %d bytes while expecting %d for command 0x%02x", received,
                    expectedSize, command);
            tunerStudioError(tsChannel, "ERROR: not enough bytes in stream");
            // MS serial protocol spec: There was a timeout before all data was received. (25ms per character.)
            sendErrorCode(tsChannel, TS_RESPONSE_UNDERRUN, "underrun");
            tsChannel->in_sync = false;
            return -1;
        }
 
        if (!isKnownCommand(command)) {
            /* print and send error as we were in sync */
            efiPrintf("unexpected command %x", command);
            sendErrorCode(tsChannel, TS_RESPONSE_UNRECOGNIZED_COMMAND, "unknown");
            tsChannel->in_sync = false;
            return -1;
        }
    } else {
        /* receive only command byte to check if it is supported */
        received = tsChannel->readTimeout((uint8_t*)(tsChannel->scratchBuffer), 1, TS_COMMUNICATION_TIMEOUT_SHORT);
        command = tsChannel->scratchBuffer[0];
 
        if (!isKnownCommand(command)) {
            /* do not report any error as we are not in sync */
            return -1;
        }
 
        received = tsChannel->readTimeout((uint8_t*)(tsChannel->scratchBuffer) + 1, expectedSize - 1, TS_COMMUNICATION_TIMEOUT);
        if (received != expectedSize - 1) {
            /* do not report any error as we are not in sync */
            return -1;
        }
    }
 
#if EFI_SIMULATOR
    logMsg("command %c\r\n", command);
#endif
 
    uint32_t expectedCrc = *(uint32_t*) (tsChannel->scratchBuffer + incomingPacketSize);
 
    expectedCrc = SWAP_UINT32(expectedCrc);
 
    uint32_t actualCrc = crc32(tsChannel->scratchBuffer, incomingPacketSize);
    if (actualCrc != expectedCrc) {
        /* send error only if previously we were in sync */
        if (tsChannel->in_sync) {
            efiPrintf("TunerStudio: command %c actual CRC %x/expected %x", tsChannel->scratchBuffer[0],
                    (unsigned int)actualCrc, (unsigned int)expectedCrc);
            tunerStudioError(tsChannel, "ERROR: CRC issue");
            sendErrorCode(tsChannel, TS_RESPONSE_CRC_FAILURE, "crc_issue");
            tsChannel->in_sync = false;
        }
        return -1;
    }
 
    /* we were able to receive known command with correct crc and size! */
    tsChannel->in_sync = true;
 
    int success = tsInstance.handleCrcCommand(tsChannel, tsChannel->scratchBuffer, incomingPacketSize);
 
    if (!success) {
        efiPrintf("got unexpected TunerStudio command %x:%c", command, command);
        return -1;
    }
 
    return 0;
}

Referenced by TunerstudioThread::ThreadTask().

Here is the call graph for this function:

Here is the caller graph for this function:

tunerStudioDebug()

void tunerStudioDebug	(	TsChannelBase *	tsChannel,
		const char *	msg
	)

Definition at line 148 of file tunerstudio.cpp.

                                                                 {
#if EFI_TUNER_STUDIO_VERBOSE
    efiPrintf("%s: %s", tsChannel->name, msg);
#endif /* EFI_TUNER_STUDIO_VERBOSE */
}

Referenced by TunerStudio::handleCrcCommand(), TunerStudio::handlePlainCommand(), handleTestCommand(), and tunerStudioError().

Here is the caller graph for this function:

tunerStudioError()

void tunerStudioError	(	TsChannelBase *	tsChannel,
		const char *	msg
	)

Definition at line 664 of file tunerstudio.cpp.

                                                                 {
    tunerStudioDebug(tsChannel, msg);
    printErrorCounters();
    tsState.errorCounter++;
}

Referenced by TunerStudio::handleCrcCommand(), tsProcessOne(), and validateOffsetCount().

Here is the call graph for this function:

Here is the caller graph for this function:

validateOffsetCount()

bool validateOffsetCount	(	size_t	offset,
		size_t	count,
		TsChannelBase *	tsChannel
	)

Definition at line 19 of file tunerstudio_commands.cpp.

                                                                                {
    if (offset + count > getTunerStudioPageSize()) {
        efiPrintf("TS: Project mismatch? Too much configuration requested %d/%d", offset, count);
        tunerStudioError(tsChannel, "ERROR: out of range");
        sendErrorCode(tsChannel, TS_RESPONSE_OUT_OF_RANGE, "bad_offset");
        return true;
    }
 
    return false;
}

Referenced by TunerStudio::handleCrc32Check(), TunerStudio::handlePageReadCommand(), TunerStudio::handleWriteChunkCommand(), and TunerStudio::handleWriteValueCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

console_line_callback

CommandHandler console_line_callback

extern

Definition at line 53 of file console_io.cpp.

Referenced by TunerStudio::handleExecuteCommand(), and startConsole().

rebootForPresetPending

bool rebootForPresetPending

extern

Definition at line 34 of file tunerstudio_commands.cpp.

Referenced by handleBurnCommand(), TunerStudio::handlePageReadCommand(), TunerStudio::handleWriteChunkCommand(), and TunerStudio::handleWriteValueCommand().

tsInstance

TunerStudio tsInstance

Definition at line 509 of file tunerstudio.cpp.

Referenced by tsProcessOne().

tsState

tunerstudio_counters_s tsState

Definition at line 662 of file tunerstudio.cpp.

Referenced by TunerStudio::cmdOutputChannels(), handleBurnCommand(), TunerStudio::handleCrc32Check(), handleGetText(), TunerStudio::handlePageReadCommand(), TunerStudio::handlePageSelectCommand(), TunerStudio::handleQueryCommand(), handleTestCommand(), TunerStudio::handleWriteChunkCommand(), TunerStudio::handleWriteValueCommand(), printErrorCounters(), resetTs(), sendErrorCode(), startTunerStudioConnectivity(), tsProcessOne(), and tunerStudioError().

Go to the source code of this file.