I have to correct myself, it seems the problem starts indeed with the processing of incoming messages. It starts after increasing the bus load, from the screenshot it is clear that the generated message (purple) is regular, while the message, that goes through the S32K onto the other CAN (azure) has outages.
I was however still not able to solve this issue.
Hello, Petr,
thank you for responding. I applied the code changes you suggested. I also set the TASD values for both CANs to its maximum value 0x1F. The effect of this is visible, but the CAN is still very unstable. As you have said, the reception of CAN messages isn't a problem, however transmitting CAN messages is stil getting delayed. I am attaching a screenshot of the cycle time of one of the CAN messages. Pink is the message that is beeing read by our ECU, black is the message our ECU is re-transmitting onto the other CAN. It is clear, that after a failed transmission, a double transmission follows, indicating that the received messages are indeed not being lost.
The circular buffers used for both receiving and transmitting messages have their value 'count' always == 0. So the CPU performence is also not a problem. Both CAN ECR registers are also == 0 all the time, co there is also no problem wit the bus.
I am attaching again the functios for loading a message for transmission from the circular buffer. This function also selects the TX MB. And the function for the transmission itself, which I also modified a bit so that it follows the User Manual instructions for TX process exactly:
ENUM_Cyrcular_buffer_return_value LoadCANFrameFromCyrcularBuffer(STRUCT_CAN_Module_Data *can_data, STRUCT_CAN_frame_buffer *buffer, STRUCT_CAN_frame *frame, uint8_t *tx_mb)
{
uint8_t i;
uint32_t tx_mb_code;
uint8_t tx_mb_temp = 0xFF;
if (buffer->count == 0)
{
// Buffer is empty.
return Empty;
}
// If 'can_data' != 0x0, it means the function is called for TX process and the TX MB must be sleected.
if (can_data != 0x0)
{
for (i = 0U; i < TX_MB_COUNT; i++)
{
tx_mb_code = (can_data->can_module->RAMn[mb_tx[i] /* Message Buffer i - odesilaci. */ * mb_sizes[can_data->data_size] /* Velikost MB v RAM. */ + 0U /* Prvni slovo MB. */] >> 24) & 0xF;
if (tx_mb_code == 8U || tx_mb_code == 9U)
{
tx_mb_temp = mb_tx[i];
break;
}
}
if (tx_mb_temp == 0xFF)
{
// No empty TX MB is available. Uses the oldest TX MB and forces it to abort before transmission.
can_data->last_tx_mb = (can_data->last_tx_mb + 1U) % TX_MB_COUNT;
*tx_mb = mb_tx[can_data->last_tx_mb];
}
else
{
*tx_mb = tx_mb_temp;
}
}
// Loads message from the buffer.
frame->id = buffer->buffer[buffer->start].id;
frame->format = buffer->buffer[buffer->start].format;
frame->len = buffer->buffer[buffer->start].len;
frame->fd_frame = buffer->buffer[buffer->start].fd_frame;
frame->brs = buffer->buffer[buffer->start].brs;
for (i = 0; i < dlcs[buffer->buffer[buffer->start].len]; i++) { frame->data[i] = buffer->buffer[buffer->start].data[i]; }
for (i = dlcs[buffer->buffer[buffer->start].len]; i < 64; i++) { frame->data[i] = 0x00; }
// Shifts the buffer.
buffer->start++;
if (buffer->start == CAN_FRAME_BUFFER_SIZE) { buffer->start = 0; }
buffer->count--;
return Buffer_ok;
}ENUM_CAN_transmit_return_value CAN_Transmit(STRUCT_CAN_Module_Data *can, STRUCT_CAN_frame can_frame, uint8_t tx_mb)
{
uint8_t i;
uint32_t tx_mb_code;
if ((can_frame.fd_frame == 1U && can->can_fd == FALSE) || (can_frame.brs == TRUE && can->can_fd == FALSE))
{
return CAN_invalid;
}
// 1. Check whether the respective interrupt bit is set and clear it.
can->can_module->IFLAG1 = (0x1 << tx_mb);
// 2. If the MB is active (transmission pending), write the ABORT code (0b1001) to the CODE field of the Control and Status word to request an abort of the transmission.
tx_mb_code = (can->can_module->RAMn[tx_mb /* Message Buffer i - odesilaci. */ * mb_sizes[can->data_size] /* Velikost MB v RAM. */ + 0U /* Prvni slovo MB. */] >> 24) & 0xF;
if (tx_mb_code != 8U && tx_mb_code != 9U)
{
can->can_module->RAMn[tx_mb /* Message Buffer */ * mb_sizes[can->data_size] /* Velikost MB v RAM. */ + 0U /* Prvni slovo MB. */] = (can->can_module->RAMn[tx_mb * mb_sizes[can->data_size]] & ~(0xF << 24)) | (0x9 << 24);
// 3. Wait for the corresponding IFLAG bit to be asserted by polling the IFLAG register, or by the interrupt request if enabled by the respective IMASK bit.
while ((can->can_module->IFLAG1 & (0x1 << tx_mb)) == 0x0) { ; }
// 4. Read back the CODE field to check if the transmission was aborted or transmitted (see Transmission abort mechanism).
tx_mb_code = (can->can_module->RAMn[tx_mb /* Message Buffer i - odesilaci. */ * mb_sizes[can->data_size] /* Velikost MB v RAM. */ + 0U /* Prvni slovo MB. */] >> 24) & 0xF;
// 5. Clear the corresponding interrupt flag.
can->can_module->IFLAG1 = (0x1 << tx_mb);
}
// 6. Write the ID register (containing the local priority if enabled via MCR[LPRIO_EN]).
can->can_module->RAMn[tx_mb /* Message Buffer */ * mb_sizes[can->data_size] /* Velikost MB v RAM. */ + 1U /* Druhe slovo MB. */] = can_frame.format == Standard ? (can_frame.id << 18) : can_frame.id;
// 7. Write payload data bytes.
for (i = 0U; i < mb_sizes[can->data_size] - 2U; i++)
{
can->can_module->RAMn[tx_mb /* Message Buffer */ * mb_sizes[can->data_size] /* Velikost MB v RAM. */ + 2U + i] = (can_frame.data[i * 4U] << 24) | (can_frame.data[(i * 4U) + 1U] << 16) | (can_frame.data[(i * 4U) + 2U] << I am also attaching the CAN periphery configuration (the same for both channels):
