The spi_device pointer you have is stored in memory somewhere. There's likely some buffer located at a lower address in memory that overflows, overwriting the spi_device pointer. Check where your spi_device pointer is declared in your code, then see if there's a variable declared before that that may be overflowing. Alternatively, attach the entire code and we can take a look.
I get this error when trying to reset mcp2517 here is the code
Code: Untitled.c Select all
esp_err_t mcp2517_reset()
{
// Reset device
if (DRV_CANFDSPI_Reset(MCP2517SPI_INDEX_0) != ESP_OK)
{
ESP_LOGE(SPI_CONTROLLER_TAG, "%s DRV_CANFDSPI_Reset failed: %s\n", __func__, esp_err_to_name(ESP_FAIL));
return ESP_FAIL;
}
else
{
ESP_LOGI(SPI_CONTROLLER_TAG, "%s DRV_CANFDSPI_Reset successfull: %s\n", __func__, esp_err_to_name(ESP_OK));
}
CAN_OSC_CTRL oscCtrl;
//CAN_OSC_STATUS osc_status;
if (DRV_CANFDSPI_OscillatorControlObjectReset(&oscCtrl) != ESP_OK)
{
ESP_LOGE(SPI_CONTROLLER_TAG, "%s DRV_CANFDSPI_OscillatorControlObjectReset failed: %s\n", __func__, esp_err_to_name(ESP_FAIL));
return ESP_FAIL;
}
else
{
ESP_LOGI(SPI_CONTROLLER_TAG, "%s DRV_CANFDSPI_OscillatorControlObjectReset successfull: %s\n", __func__, esp_err_to_name(ESP_OK));
}
oscCtrl.PllEnable = 1;
if (DRV_CANFDSPI_OscillatorControlSet(MCP2517SPI_INDEX_0, oscCtrl) != ESP_OK)
{
ESP_LOGE(SPI_CONTROLLER_TAG, "%s DRV_CANFDSPI_OscillatorControlSet failed: %s\n", __func__, esp_err_to_name(ESP_FAIL));
return ESP_FAIL;
}
else
{
ESP_LOGI(SPI_CONTROLLER_TAG, "%s DRV_CANFDSPI_OscillatorControlSet successfull: %s\n", __func__, esp_err_to_name(ESP_OK));
}
// Enable ECC and initialize RAM
if (DRV_CANFDSPI_EccEnable(MCP2517SPI_INDEX_0) != ESP_OK)
{
ESP_LOGE(SPI_CONTROLLER_TAG, "%s DRV_CANFDSPI_EccEnable failed: %s\n", __func__, esp_err_to_name(ESP_FAIL));
return ESP_FAIL;
}
else{
ESP_LOGI(SPI_CONTROLLER_TAG, "%s DRV_CANFDSPI_EccEnable successfull: %s\n", __func__, esp_err_to_name(ESP_OK));
}
[b][u][size=150][size=200][size=150][color=#FF0000]if (DRV_CANFDSPI_RamInit(MCP2517SPI_INDEX_0, 0xff) != ESP_OK)[/color][/size][/size][/size][/u][/b]
{
ESP_LOGE(SPI_CONTROLLER_TAG, "%s DRV_CANFDSPI_RamInit failed: %s\n", __func__, esp_err_to_name(ESP_FAIL));
return ESP_FAIL;
}
else{
ESP_LOGI(SPI_CONTROLLER_TAG, "%s DRV_CANFDSPI_RamInit successfull: %s\n", __func__, esp_err_to_name(ESP_OK));
}
/* DRV_CANFDSPI_OscillatorStatusGet(MCP2517SPI_INDEX_0, &osc_status);
ets_printf("pll-%d, osc-%d, sclk-%d \r\n", osc_status.PllReady, osc_status.OscReady, osc_status.SclkReady);*/
return ESP_OK;
}
and the log output:
I (1156) spi_master: SPI3: New device added to CS0, effective clock: 13333kHz
I (1166) SPI_CONTROLLER: spi_controller_init spi initialized: ESP_OK
I (1166) SPI_CONTROLLER: mcp2517_reset DRV_CANFDSPI_Reset successfull: ESP_OK
I (1176) SPI_CONTROLLER: mcp2517_reset DRV_CANFDSPI_OscillatorControlObjectReset successfull: ESP_OK
I (1196) SPI_CONTROLLER: mcp2517_reset DRV_CANFDSPI_OscillatorControlSet successfull: ESP_OK
I (1206) SPI_CONTROLLER: mcp2517_reset DRV_CANFDSPI_EccEnable successfull: ESP_OK
Problem occurs in
RAMInit
Code: Untitled.c Select all
uint8_t DRV_CANFDSPI_RamInit(CANFDSPI_MODULE_ID index, uint8_t d)
{
uint8_t txd[SPI_DEFAULT_BUFFER_LENGTH];//SPI_DEFAULT_BUFFER_LENGTH=64
uint8_t spiTransferError = 0;
// Prepare data
for (uint8_t k = 0; k < SPI_DEFAULT_BUFFER_LENGTH; k++)
{
txd[k] = d;
}
uint16_t a = cRAMADDR_START;
for (uint8_t k = 0; k < (cRAM_SIZE / SPI_DEFAULT_BUFFER_LENGTH); k++)
{
spiTransferError = DRV_CANFDSPI_WriteByteArray(index, a, txd, SPI_DEFAULT_BUFFER_LENGTH);
if (spiTransferError)
{
return -1;
}
a += SPI_DEFAULT_BUFFER_LENGTH;
}
return spiTransferError;
}
Code: Untitled.c Select all
uint8_t DRV_CANFDSPI_WriteByteArray(CANFDSPI_MODULE_ID index, uint16_t address,
uint8_t *txd, uint16_t nBytes)
{
uint16_t i;
uint16_t spiTransferSize = nBytes + 2;
uint8_t spiTransferError = 0;
// Compose command
spiTransmitBuffer[0] = (uint8_t)((cINSTRUCTION_WRITE << 4) + ((address >> 8) & 0xF));
spiTransmitBuffer[1] = (uint8_t)(address & 0xFF);
// Add data
for (i = 2; i < spiTransferSize; i++)
{
spiTransmitBuffer[i] = txd[i - 2];
}
spiTransferError = SPI_TransferData(spiTransmitBuffer, spiReceiveBuffer, spiTransferSize);
return spiTransferError;
}
Code: Untitled.c Select all
//-----------------------------------------------------------------------------------------------------------------------------------------
esp_err_t SPI_TransferData(const uint8_t *SpiTxData, uint8_t *SpiRxData, uint16_t spiTransferSize)
{
assert(spi_device != NULL);
esp_err_t ret = spi_master_transfer(spi_device, SpiTxData, SpiRxData, spiTransferSize);
return ret;
}
Code: Untitled.c Select all
static esp_err_t spi_master_transfer(spi_device_handle_t spi_device, const uint8_t *SpiTxData, uint8_t *SpiRxData, uint16_t len)
{
spi_transaction_t t;
if (len == 0)
return ESP_FAIL; // no need to send anything
// Zero out the transaction
memset(&t, 0, sizeof(t));
t.length = len * 8; // Len is in bytes, transaction length is in bits.
t.tx_buffer = SpiTxData;
esp_err_t ret = spi_device_transmit(spi_device, &t);
if (ret != ESP_OK)
{
ESP_LOGE(SPI_TAG, "%s spi_device_transmit failed! %s\n", __func__, esp_err_to_name(ESP_FAIL));
return ESP_FAIL;
}
return ESP_OK;
}
Code: Untitled.c Select all
// Porcelain to do one blocking transmission.
esp_err_t SPI_MASTER_ATTR spi_device_transmit(spi_device_handle_t handle, spi_transaction_t *trans_desc)
{
esp_err_t ret;
spi_transaction_t *ret_trans;
// ToDo: check if any spi transfers in flight
ret = spi_device_queue_trans(handle, trans_desc, portMAX_DELAY);
if (ret != ESP_OK)
return ret;
ret = spi_device_get_trans_result(handle, &ret_trans, portMAX_DELAY);
if (ret != ESP_OK)
{
ESP_LOGI(SPI_TAG, "spi_device_get_trans_result%d", ret);
return ret;
};
assert(ret_trans == trans_desc);
return ESP_OK;
}
Code: Untitled.c Select all
esp_err_t SPI_MASTER_ATTR spi_device_queue_trans(spi_device_handle_t handle, spi_transaction_t *trans_desc, TickType_t ticks_to_wait)
{
esp_err_t ret = check_trans_valid(handle, trans_desc);
if (ret != ESP_OK)
return ret;
spi_host_t *host = handle->host;
SPI_CHECK(!spi_bus_device_is_polling(handle), "Cannot queue new transaction while previous polling transaction is not terminated.", ESP_ERR_INVALID_STATE);
/* Even when using interrupt transfer, the CS can only be kept activated if the bus has been
* acquired with `spi_device_acquire_bus()` first. */
if (host->device_acquiring_lock != handle && (trans_desc->flags & SPI_TRANS_CS_KEEP_ACTIVE))
{
return ESP_ERR_INVALID_ARG;
}
spi_trans_priv_t trans_buf;
ret = setup_priv_desc(trans_desc, &trans_buf, (host->bus_attr->dma_enabled));
if (ret != ESP_OK)
return ret;
#ifdef CONFIG_PM_ENABLE
esp_pm_lock_acquire(host->bus_attr->pm_lock);
#endif
// Send to queue and invoke the ISR.
BaseType_t r = xQueueSend(handle->trans_queue, (void *)&trans_buf, ticks_to_wait);
if (!r)
{
ret = ESP_ERR_TIMEOUT;
#ifdef CONFIG_PM_ENABLE
// Release APB frequency lock
esp_pm_lock_release(host->bus_attr->pm_lock);
#endif
goto clean_up;
}
// The ISR will be invoked at correct time by the lock with `spi_bus_intr_enable`.
ret = spi_bus_lock_bg_request(handle->dev_lock);
if (ret != ESP_OK)
{
goto clean_up;
}
return ESP_OK;
clean_up:
uninstall_priv_desc(&trans_buf);
return ret;
}
Code: Untitled.c Select all
static SPI_MASTER_ISR_ATTR esp_err_t check_trans_valid(spi_device_handle_t handle, spi_transaction_t *trans_desc)
{
SPI_CHECK(handle != NULL, "invalid dev handle", ESP_ERR_INVALID_ARG);
spi_host_t *host = handle->host;
const spi_bus_attr_t *bus_attr = host->bus_attr;
...
and down below I declare the spi_device
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "freertos/queue.h"
#include "rom/ets_sys.h"
#include "esp_system.h"
#include "driver/gpio.h"
#include "spi.h"
#include "driver/spi_master.h"
#include "esp_err.h"
#include "esp_log.h"
#include "mcp2517_defines.h"
#define SPI_TAG "SPI"
#define CAN_SPI_HOST VSPI_HOST
#define DMA_CHAN 2
#define DMA_ENABLED 1
#define SERIAL_CLOCK_SPEED 12500000
#define PIN_NUM_MISO 19
#define PIN_NUM_MOSI 23
#define PIN_NUM_CLK 18
#define PIN_NUM_CS 5
spi_device_handle_t spi_device = NULL;
extern esp_err_t receive_canFrame();
/* Local function prototypes */
static esp_err_t spi_master_init(void);
static esp_err_t spi_master_transfer(spi_device_handle_t spi_device, const uint8_t *SpiTxData, uint8_t *SpiRxData, uint16_t len);
static esp_err_t spi_master_read(uint8_t spiSlaveDeviceIndex, const uint8_t *SpiTxData, uint8_t *SpiRxData, uint16_t len);
//! SPI Initialization
esp_err_t SPI_Initialize(void);
//! SPI Read/Write Transfer
esp_err_t SPI_TransferData(const uint8_t *SpiTxData, uint8_t *SpiRxData, uint16_t spiTransferSize);
esp_err_t SPI_ReadData(uint8_t spiSlaveDeviceIndex, const uint8_t *SpiTxData, uint8_t *SpiRxData, uint16_t spiTransferSize);
