The guide is in progress….

Introduction

New for RaceROM version 9 is a fully adjustable secondary injection system, the basic operation is as follows (there are more steps and calculations but these are the basics)

Secondary injection activation is determined based on load, projected secondary inj pw and duty
The desired overall fuel mass for the current stroke is calculated
If secondary injection is active, the total fuel mass is divided between the primary and secondary injections based on the split %
The required secondary fuel mass is converted into an injection time based on calibrated injector flow rate at the measured differential pressure
The calculated secondary injector lag time is determined from calibrated map using differential fuel pressure and voltage
Total secondary injector pw is send to the external device and used to turn on the injector (timing is handled entirely by the external device)
Primary injector effective pulse width is trimmed to compensate for the mass of fuel delivered by the secondary injectors

Tuning

Before attempting to tune the secondary injection, first be absolutely sure the engine is accurately calibrated using only the primary injectors.

Once enabled in SI Control Options there are four key elements to tuning the secondary injection:

Ensure the primary and secondary injector scaling is accurate
Ensure the primary and secondary injector lag times are accurate
Set the proportion of fuel for the secondary injectors to inject using SI Secondary Injection Target (Gasoline)/(Ethanol)
Set the maximum duty cycle you would like to see on the primary injectors using SI Pri Duty Cycle Maximum

We cannot stress enough how absolutely important it is to have the injector flow rates and lag times set accurate for both sets of injectors is. Errors that may not be apparent when using just the primary injectors can become much more significant when using two sets of injectors. Do not rush, do not just assume you can tune a car from scratch at high power using ethanol and secondary injection without first checking the basics.

Datalogging

TBA

CAN Protocol

For the secondary injection to work successfully there are two CAN packets involved, one sent from the ECU to the secondary injection driver and another that is sent back from SI driver to the ecu. This may be subject to change or addition in future.

RaceROM Can Input (received by the ECU from the device)

Baud 500kb/s. 11bit default ID 0x334. Recommend frequency 25 or 50hz

Byte 1		Byte 2	Byte 3	Byte 4	Byte 5	Byte 6	Byte 7	Byte 8
Version	Multiplex	Pulsewidth Actual		Fuel Pressure	Ethanol %	Aux Input	Error Flags	Checksum

Byte	Name	Scaling
1	Version (4 bits) Multiplex (4 bits)	Fixed value. Currently 0x11.
2&3	Pulsewidth Actual (16 bit big endian)	0.01ms/bit.
4	Fuel Pressure (8 bit)	10kPa/bit (0.1 bar/bit).
5	Ethanol Content (8 bit)	1%/bit.
6	Aux Input (8 bit)	unscaled.
7	Error Flags (8 bit)	0 = good, non-zero indicates error.
8	Checksum (8 bit)	CRC8 algorithm.

RaceROM CAN Output (sent from the ECU to the device)

Baud 500kb/s. 11bit ID Default ID 0x335 default 25Hz

Byte 1		Byte 2	Byte 3	Byte 4	Byte 5	Byte 6	Byte 7	Byte 8
Version	Multiplex	Pulsewidth Target		Aux Output 1		Aux Output 2	Injector Enable	Checksum

Byte	Name	Scaling
1	Version (4 bits) Multiplex (4 bits)	Fixed Value. Currently 0x11.
2&3	Pulsewidth Target (16 bit Big Endian)	0.01 ms/bit.
4&5	Aux Output 1 (16 bit Big Endian)	0.1% per bit
6	Aux Output 2 (8 bit)	1% per bit
7	Injector Enable Mask (8 bits)	1 bit for each injector, 1 = ON
8	Checksum (8 bit)	CRC8 algorithm

CRC8 Algorithm

For some of our EcuTek defined CAN packets, a CRC is employed to validate that the data is sent from the device we are expecting and not some other random device with the same CAN ID. We also send a checksum value that your device can check to validate the data sent by the ECU.

Below is the exact function used which can be replicated by third party device makers.

const uint8 CRC8_TABLE_LO[] = { 0x00, 0x1D, 0x3A, 0x27, 0x74, 0x69, 0x4E, 0x53, 0xE8, 0xF5, 0xD2, 0xCF, 0x9C, 0x81, 0xA6, 0xBB };
const uint8 CRC8_TABLE_HI[] = { 0x00, 0xCD, 0x87, 0x4A, 0x13, 0xDE, 0x94, 0x59, 0x26, 0xEB, 0xA1, 0x6C, 0x35, 0xF8, 0xB2, 0x7F };

uint8 COM_calc_crc8(uint8 *buffer, uint8 len, uint8 skip, uint8 crc)
{
  uint32 j;
  uint8 data;
 
       for(j=0;j<len;j++)
       {
              if (j != skip)
              {
                     data = buffer[j];
                     data = data ^ crc;
                     crc  = CRC8_TABLE_HI[data >> 4] ^ CRC8_TABLE_LO[data & 0x0F];     
              }
       }
       return crc;
}

To use the function:

buffer is a pointer to the 8 bytes of CAN data,

len is the length of the CAN data (normally 8)

skip is the index of the checksum byte which gets excluded from the calculation

crc is the initial value of the checksum, we can define this per device but we normally just use FF

Support

GTR RaceROM V9 Secondary Injection