I was wondering if there is any external component for making ESP32S3 compatible with CAN-FD.The TWAI controller is not compatible with ISO11898-1 FD Format frames, and will interpret such frames as errors.
I'm going this same route! Currently have it working with hacked up canbed (separate 2518 and xcvr) am working on a board with the 251863DrMickeyLauer wrote: ↑Fri May 12, 2023 4:20 pmUnfortunately there is nothing ready made. Sadly, Espressif seems to ignore the fact that CAN-FD is spreading a lot. (Much like they ditched RMII, which I still can't understand).
What did you end up using? I have to do the same soon, trying to make a MCP251863 (MCP2518fd + transceiver) work with my ESP32C6.
Excellent. Would be cool to hear about your progress. By the way, as I'm working via ESP-IDF, not Arduino, I have yet to find a driver example for the MCP2518fd. I'm not yet working on it, but will be very soon. Perhaps we can share some code for that.samsonx wrote: ↑Mon May 15, 2023 5:58 amI'm going this same route! Currently have it working with hacked up canbed (separate 2518 and xcvr) am working on a board with the 251863DrMickeyLauer wrote: ↑Fri May 12, 2023 4:20 pmUnfortunately there is nothing ready made. Sadly, Espressif seems to ignore the fact that CAN-FD is spreading a lot. (Much like they ditched RMII, which I still can't understand).
What did you end up using? I have to do the same soon, trying to make a MCP251863 (MCP2518fd + transceiver) work with my ESP32C6.
Any progress on this ?DrMickeyLauer wrote: ↑Wed May 17, 2023 10:27 amExcellent. Would be cool to hear about your progress. By the way, as I'm working via ESP-IDF, not Arduino, I have yet to find a driver example for the MCP2518fd. I'm not yet working on it, but will be very soon. Perhaps we can share some code for that.samsonx wrote: ↑Mon May 15, 2023 5:58 amI'm going this same route! Currently have it working with hacked up canbed (separate 2518 and xcvr) am working on a board with the 251863DrMickeyLauer wrote: ↑Fri May 12, 2023 4:20 pmUnfortunately there is nothing ready made. Sadly, Espressif seems to ignore the fact that CAN-FD is spreading a lot. (Much like they ditched RMII, which I still can't understand).
What did you end up using? I have to do the same soon, trying to make a MCP251863 (MCP2518fd + transceiver) work with my ESP32C6.
Code: Select all
static eERRORRESULT mcp251x_spi_transfer(void *pIntDev, uint8_t chipSelect, uint8_t *txData, uint8_t *rxData, size_t size) {
if (!txData) {
return ERR__SPI_PARAMETER_ERROR;
}
auto object = reinterpret_cast<ESP_MCP251XFD*>(pIntDev);
auto locker = CriticalSection(object->spiSemaphore);
auto result = object->spiDevice->transfer(txData, rxData, size);
if (result != ESP_OK) {
ESP_LOGE(TAG, "SPI Communication Error: %d", result);
return ERR__SPI_COMM_ERROR;
}
return ERR_NONE;
}
Code: Select all
esp_err_t Device::transfer(uint8_t* txdata, uint8_t* rxdata, size_t length) {
spi_transaction_t t = {
.flags = 0,
.cmd = 0,
.addr = 0,
.length = length * 8, // write register number, write value
.rxlength = length * 8,
.user = nullptr,
.tx_buffer = txdata,
.rx_buffer = rxdata,
};
auto result = spi_device_polling_transmit(handle, &t);
return result;
}
Code: Select all
//----------------------------------------------------------------
// ISR
//----------------------------------------------------------------
void IrqHandlerTask::irqHandlerISR(void* arg) {
auto irqHandler = static_cast<IrqHandlerTask*>(arg);
#ifdef ESP_MCP251XFD_ENABLE_IRQ_DEADLOCK_TIMER
// Create irq deadlock timer, if not existing
if (!irqHandler->irqDeadlockTimer) {
const esp_timer_create_args_t timerConfiguration = {
.callback = &irqHandlerDeadlockTimerCallback,
.arg = arg,
.dispatch_method = ESP_TIMER_TASK,
.name = "IRQ-Deadlock-Timeout",
.skip_unhandled_events = false,
};
esp_timer_create(&timerConfiguration, &irqHandler->irqDeadlockTimer);
}
#endif
#ifdef ESP_MCP251XFD_ENABLE_IRQ_DEADLOCK_TIMER
bool irqActive = !gpio_get_level(irqHandler->device->irqPin);
if (irqActive) {
//ESP_EARLY_LOGI("IRQ", "Launching deadlock timer...");
esp_timer_start_once(irqHandler->irqDeadlockTimer, 1000000);
#endif
// Wake up IRQ handler task
auto xHigherPriorityTaskWoken = irqHandler->notifyGiveFromISR();
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
#ifdef ESP_MCP251XFD_ENABLE_IRQ_DEADLOCK_TIMER
} else {
esp_timer_stop(irqHandler->irqDeadlockTimer);
//ESP_EARLY_LOGI("IRQ", "Cancelling deadlock timer...");
}
#endif
}
Code: Select all
class ESP_MCP251XFD {
friend class IrqHandlerTask;
enum Alert: uint8_t {
None = 0,
BusError = 1 << 0,
ReceiveOverflow = 1 << 5,
};
public:
static std::unique_ptr<ESP_MCP251XFD> createDevice(std::unique_ptr<SPI::Device> device, gpio_num_t irqPin, uint8_t xtalMHz = 40, bool gpiosControlTransceiverStandby = false);
/// Start the device in normal mode with the requested `nominal` bitrate and, if mixed CAN/CAN-FD is requested, the `data` bitrate.
bool start(uint32_t nominal, uint32_t data = 0, uint32_t minimumInterframeInterval = 0);
/// Start the device in receive-only mode, with the requested `nominal` bitrate and, if mixed CAN/CAN-FD is requested, the `data` bitrate.
bool startReceiveOnly(uint32_t nominal, uint32_t data = 0);
/// Stop the device.
void stop();
/// Release resources for the MCP251XFD device.
virtual ~ESP_MCP251XFD();
// Delete copy constructor (we're encapsulating a hardware resource)
ESP_MCP251XFD(const ESP_MCP251XFD&) = delete;
// Delete copy assignment operator (dito)
ESP_MCP251XFD& operator=(const ESP_MCP251XFD&) = delete;
/// Auto-detect the bitrate.
uint32_t autodetectBitrate(std::vector<uint32_t>& bitrates);
/// Update the acceptance filter.
bool updateFilter(uint32_t mask, uint32_t pattern);
/// Update the bitrate.
bool updateBitrate(uint32_t nominal, uint32_t data = 0, uint32_t minimumInterfaceInterval = 0);
/// Transmit a single frame.
bool transmit(const CANMessage& message);
/// Transmit multiple frames.
bool transmit(std::vector<CANMessage>& messages);
/// Receive a single frame.
bool receive(CANMessage** message, TickType_t timeout = portMAX_DELAY);
/// Return the current set of alerts and reset it.
Alert currentAlerts() {
auto alertAccess = CriticalSection(alertMutex);
Alert currentAlerts = alerts;
alerts = Alert::None;
return currentAlerts;
}
public:
uint32_t bitrate; // in bits per second
uint32_t sysclk; // in Hz
uint32_t interframeInterval; // in microseconds
uint32_t timestamp();
public /* private */:
std::unique_ptr<SPI::Device> spiDevice = nullptr;
MCP251XFD* mcpDevice = nullptr;
SemaphoreHandle_t spiSemaphore = NULL;
bool spi_debug_enabled = false;
bool irqHandlingEnabled = false;
protected:
void startIRQHandling();
void handleIRQ(); // Called from IRQ Handler task
void handleIRQDeadlockTimeout(); // Called from FreeRTOS Timer task
void stopIRQHandling();
void sleep();
void updateAlerts(Alert alert) {
auto alertAccess = CriticalSection(alertMutex);
alerts = static_cast<Alert>(static_cast<uint8_t>(alerts) | static_cast<uint8_t>(alert));
}
// Transmit a message to the TX FIFO. @returns true, if there is no space.
bool transmitToFifoIfPossible(const CANMessage& message);
private:
ESP_MCP251XFD(std::unique_ptr<SPI::Device> device, gpio_num_t irqPin, uint8_t xtalMHz, bool gpiosControlTransceiverStandby);
private:
gpio_num_t irqPin;
uint8_t xtalMHz;
bool gpiosControlTransceiverStandby;
std::unique_ptr<IrqHandlerTask> irqHandler = nullptr;
std::unique_ptr<Queue<CANMessage*>> receiveQueue = nullptr;
Mutex outgoingMessagesMutex;
std::queue<CANMessage> outgoingMessages;
Mutex alertMutex;
Alert alerts = Alert::None;
};