rusefi_wideband.h File Reference

Functions
size_t	getWidebandBus ()
void	sendWidebandInfo ()
void	handleWidebandCan (const size_t busIndex, const CANRxFrame &frame)
void	pingWideband (uint8_t hwIndex)
void	setWidebandOffsetNoWait (uint8_t hwIndex, uint8_t index)
void	setWidebandOffset (uint8_t hwIndex, uint8_t index)
void	setWidebandSensorType (uint8_t hwIndex, uint8_t type)
void	updateWidebandFirmware (uint8_t hwIndex)

Function Documentation

getWidebandBus()

size_t getWidebandBus

(

)

Definition at line 22 of file rusefi_wideband.cpp.

                        {
    return engineConfiguration->widebandOnSecondBus ? 1 : 0;
}

Referenced by AemXSeriesWideband::acceptFrame(), handleWidebandCan(), pingWideband(), sendWidebandInfo(), setWidebandOffsetNoWait(), setWidebandSensorType(), and updateWidebandFirmware().

Here is the caller graph for this function:

handleWidebandCan()

void handleWidebandCan	(	const size_t	busIndex,
		const CANRxFrame &	frame
	)

Definition at line 30 of file rusefi_wideband.cpp.

                                                                       {
    // wrong bus
    if (busIndex != getWidebandBus()) {
        return;
    }
 
    // Bootloader acks with address 0x727573 aka ascii "rus"
    if (CAN_EID(frame) != WB_ACK) {
        return;
    }
 
    if (frame.DLC == 0)
    {
        // Ack reply
        // Nop
    } else if (frame.DLC == 8)
    {
        // Ping reply
        #if EFI_TUNER_STUDIO
            auto data = reinterpret_cast<const wbo::PongData*>(&frame.data8[0]);
 
            engine->outputChannels.canReWidebandVersion = data->Version;
            engine->outputChannels.canReWidebandFwDay = data->day;
            engine->outputChannels.canReWidebandFwMon = data->month;
            engine->outputChannels.canReWidebandFwYear = data->year;
        #endif
    } else {
        // Unknown
        return;
    }
 
    // Wake thread in any case
    auto t = waitingBootloaderThread;
    if (t) {
        chEvtSignal(t, EVT_BOOTLOADER_ACK);
    }
}

Referenced by processCanRxMessage().

Here is the call graph for this function:

Here is the caller graph for this function:

pingWideband()

void pingWideband

(

uint8_t

hwIndex

)

Definition at line 151 of file rusefi_wideband.cpp.

                                   {
    size_t bus = getWidebandBus();
 
    setStatus(WBO_RE_BUSY);
 
#if EFI_TUNER_STUDIO
    engine->outputChannels.canReWidebandVersion = 0;
    engine->outputChannels.canReWidebandFwDay = 0;
    engine->outputChannels.canReWidebandFwMon = 0;
    engine->outputChannels.canReWidebandFwYear = 0;
#endif
 
    // Clear any pending acks for this thread
    chEvtGetAndClearEvents(EVT_BOOTLOADER_ACK);
 
    // Send messages to the current thread when acks come in
    waitingBootloaderThread = chThdGetSelfX();
 
    {
        // TODO: replace magic number with WB_MSG_PING after updating Wideband submodule
        CanTxMessage m(CanCategory::WBO_SERVICE, 0xEF6'0000, 1, bus, true);
        m[0] = hwIndex;
    }
 
    // 25mS should be enought, lets do not block TS thread too long while waiting for WBO reply
    if (!waitAck(25)) {
        efiPrintf("Wideband ping failed: no controller detected!");
        setStatus(WBO_RE_FAILED);
    } else {
        efiPrintf("WBO_RE_DONE");
        setStatus(WBO_RE_DONE);
    }
 
    waitingBootloaderThread = nullptr;
}

Referenced by executeTSCommand(), and initBenchTest().

Here is the call graph for this function:

Here is the caller graph for this function:

sendWidebandInfo()

void sendWidebandInfo

(

)

Definition at line 188 of file rusefi_wideband.cpp.

                        {
    static int counter = 0;
 
    CanTxMessage m(CanCategory::WBO_SERVICE, WB_MGS_ECU_STATUS, /*dlc*/2, getWidebandBus(), /*isExtended*/true);
 
    float vbatt = Sensor::getOrZero(SensorType::BatteryVoltage) * 10;
 
    m[0] = vbatt;
 
    // Offset 1 bit 0 = heater enable
    m[1] = engine->engineState.heaterControlEnabled ? 0x01 : 0x00;
 
    // 10 * 50 = 0.5S delay
    if (counter == 10) {
        for (size_t i = 0; i < CAN_WBO_COUNT; i++) {
            if ((engineConfiguration->canWbo[i].enableRemap) &&
                (engineConfiguration->canWbo[i].type == RUSEFI)) {
                // remap
                setWidebandOffsetNoWait(engineConfiguration->canWbo[i].reHwidx, engineConfiguration->canWbo[i].reId);
            }
        }
    }
 
    counter++;
}

Referenced by CanWrite::PeriodicTask().

Here is the call graph for this function:

Here is the caller graph for this function:

setWidebandOffset()

void setWidebandOffset	(	uint8_t	hwIndex,
		uint8_t	index
	)

Definition at line 92 of file rusefi_wideband.cpp.

                                                       {
    setStatus(WBO_RE_BUSY);
 
    // Clear any pending acks for this thread
    chEvtGetAndClearEvents(EVT_BOOTLOADER_ACK);
 
    // Send messages to the current thread when acks come in
    waitingBootloaderThread = chThdGetSelfX();
 
    efiPrintf("***************************************");
    efiPrintf("          WIDEBAND INDEX SET");
    efiPrintf("***************************************");
 
    if (hwIndex == 0xff) {
        efiPrintf("Setting all connected widebands to index %d...", index);
    } else {
        efiPrintf("Setting wideband with hwIndex %d to CAN index %d...", hwIndex, index);
    }
    setWidebandOffsetNoWait(hwIndex, index);
 
    if (!waitAck()) {
        efiPrintf("Wideband index set failed: no controller detected!");
        setStatus(WBO_RE_FAILED);
    } else {
        setStatus(WBO_RE_DONE);
    }
 
    waitingBootloaderThread = nullptr;
}

Referenced by executeTSCommand(), and initBenchTest().

Here is the call graph for this function:

Here is the caller graph for this function:

setWidebandOffsetNoWait()

void setWidebandOffsetNoWait	(	uint8_t	hwIndex,
		uint8_t	index
	)

Definition at line 79 of file rusefi_wideband.cpp.

                                                             {
    size_t bus = getWidebandBus();
 
    if (hwIndex == 0xff) {
        CanTxMessage m(CanCategory::WBO_SERVICE, WB_MSG_SET_INDEX, 1, bus, true);
        m[0] = index;
    } else {
        CanTxMessage m(CanCategory::WBO_SERVICE, WB_MSG_SET_INDEX, 2, bus, true);
        m[0] = index;
        m[1] = hwIndex;
    }
}

Referenced by sendWidebandInfo(), and setWidebandOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

setWidebandSensorType()

void setWidebandSensorType	(	uint8_t	hwIndex,
		uint8_t	type
	)

Definition at line 122 of file rusefi_wideband.cpp.

                                                          {
    size_t bus = getWidebandBus();
 
    setStatus(WBO_RE_BUSY);
 
    // Clear any pending acks for this thread
    chEvtGetAndClearEvents(EVT_BOOTLOADER_ACK);
 
    // Send messages to the current thread when acks come in
    waitingBootloaderThread = chThdGetSelfX();
 
    {
        // Note position of hwIndex, compared to WB_MSG_SET_INDEX
        // TODO: replace madic number after updating WBO submodule
        CanTxMessage m(CanCategory::WBO_SERVICE, 0xEF7'0000 /* WB_MSG_SET_SENS_TYPE */, 2, bus, true);
        m[0] = hwIndex;
        m[1] = type;
    }
 
    if (!waitAck()) {
        efiPrintf("Wideband sensor type set failed: no controller detected!");
        setStatus(WBO_RE_FAILED);
    } else {
        setStatus(WBO_RE_DONE);
    }
 
    waitingBootloaderThread = nullptr;
}

Referenced by executeTSCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

updateWidebandFirmware()

void updateWidebandFirmware

(

uint8_t

hwIndex

)

Definition at line 220 of file rusefi_wideband.cpp.

                                             {
    size_t bus = getWidebandBus();
    size_t totalSize = sizeof(build_wideband_image_bin);
 
    setStatus(WBO_RE_BUSY);
 
    // Clear any pending acks for this thread
    chEvtGetAndClearEvents(EVT_BOOTLOADER_ACK);
 
    // Send messages to the current thread when acks come in
    waitingBootloaderThread = chThdGetSelfX();
 
    efiPrintf("***************************************");
    efiPrintf("        WIDEBAND FIRMWARE UPDATE");
    efiPrintf("***************************************");
    if (hwIndex != 0xff) {
        efiPrintf("Wideband Update: Rebooting WBO hwIndex %d to bootloader...", hwIndex);
    } else {
        efiPrintf("Wideband Update: Rebooting any WBO to bootloader...");
    }
    // The first request will reboot the chip (if necessary), and the second one will enable bootloader mode
    // If the chip was already in bootloader (aka manual mode), then that's ok - the second request will
    // just be safely ignored (but acked)
    for (int i = 0; i < 2; i++) {
        // Send bootloader entry command
        // First packet will ask main FW to reboot to bootloader
        // Second will ask bootloader to stay in bootloader and wait for FW upload
        // First packet can be new format - individually addressed
        // Second one should have zero payload - bootloader expects no payload.
        if ((hwIndex != 0xff) && (i == 0)) {
            // New format - individually addressed
            CanTxMessage m(CanCategory::WBO_SERVICE, WB_BL_ENTER, 1, bus, true);
            m[0] = hwIndex;
        } else {
            CanTxMessage m(CanCategory::WBO_SERVICE, WB_BL_ENTER, 0, bus, true);
        }
 
        if (!waitAck()) {
            efiPrintf("Wideband Update ERROR: Expected ACK from entry to bootloader, didn't get %s.",
                i ? "second (from bootloader)" : "first (from app)");
            setStatus(WBO_RE_FAILED);
            goto exit;
        }
 
        // Let the controller reboot (and show blinky lights for a second before the update begins)
        chThdSleepMilliseconds(200);
    }
 
    efiPrintf("Wideband Update: in update mode, erasing flash...");
 
    {
        // Erase flash - opcode 1, magic value 0x5A5A
        // TODO: replace magic numer with WB_BL_ERASE when define is fixed in wideband_can.h, currently mess with shift and addition precedence
        //CanTxMessage m(CanCategory::WBO_SERVICE, WB_BL_ERASE, 0, bus, true);
        CanTxMessage m(CanCategory::WBO_SERVICE, 0xEF1'5A5A, 0, bus, true);
    }
 
    if (!waitAck()) {
        efiPrintf("Wideband Update ERROR: Expected ACK from flash erase command, didn't get one.");
        setStatus(WBO_RE_FAILED);
        goto exit;
    }
 
    efiPrintf("Wideband Update: Flash erased! Sending %d bytes...", totalSize);
 
    // Send flash data 8 bytes at a time
    for (size_t i = 0; i < totalSize; i += 8) {
        {
            CanTxMessage m(CanCategory::WBO_SERVICE, WB_BL_DATA_BASE | i, 8, bus, true);
            memcpy(&m[0], build_wideband_image_bin + i, 8);
        }
 
        if (!waitAck()) {
            efiPrintf("Wideband Update ERROR: Expected ACK from data write, didn't get one.");
            setStatus(WBO_RE_FAILED);
            goto exit;
        }
    }
 
    efiPrintf("Wideband Update: Update complete! Rebooting controller.");
 
    {
        // Reboot to firmware!
        CanTxMessage m(CanCategory::WBO_SERVICE, WB_BL_REBOOT, 0, bus, true);
    }
 
    // TODO:
    waitAck();
 
    setStatus(WBO_RE_DONE);
 
exit:
    waitingBootloaderThread = nullptr;
}

Here is the call graph for this function:

Go to the source code of this file.