SPI and new problems

[ir2pemoj@uco.es]

Hello guys!

I have more problems with spi. Need write into a sd card and read data from can bus throw MCP2515...
I am trying to start with the basics, which is to make the spi bus work as it should, so I have connected my esp32 to an arduino (as a slave) to try a communication. The arduino always receives 0xFF. So I have decided to connect a logic analyzer in the 4 ways of the SPI and this is the result:

CH0 = CLK
CH1 = MOSI
CH2 = MISO
CH3 = CS

Is a capture of 5 seconds. My code send one byte each second...


This is detailed each send:








My code is:

Code: Select all

#ifdef __cplusplus
    extern "C" {
#endif


    typedef struct {
        spi_host_device_t host;     ///El host SPI utilizado
        gpio_num_t cs;              ///Pin CS utilizado
        gpio_num_t miso;            ///Pin MISO utilizado
        gpio_num_t mosi;            ///Pin MOSI utilizado
        gpio_num_t clk;             ///Pin CLK utilizado
        bool intr_used;             ///Utilización de interrupciones
    } spi_config_t;


    /// Configuracion del SPI
    struct spi_context_t{
        spi_config_t cfg;               ///Configuracion
        spi_device_handle_t handle;     ///SPI handle
        xSemaphoreHandle ready_sem;     ///Semaforo
    }; 


#ifndef BIT64
#define BIT64(nr)               (1ULL << (nr))
#endif

#define SPI_CLK_FREQ         (1*1000*1000)

//VSPI
const gpio_num_t GPIO_MOSI = GPIO_NUM_23;
const gpio_num_t GPIO_MISO = GPIO_NUM_19;
const gpio_num_t GPIO_SCLK = GPIO_NUM_18;

const char *spiTAG = "SPI";

spi_context_t* ctx;


static void spi_task(void *pvParameter);
esp_err_t SPI_begin(gpio_num_t pCS);
esp_err_t SPI_begin1(spi_host_device_t host, gpio_num_t pMOSI, gpio_num_t pMISO, gpio_num_t pCLK, gpio_num_t pCS);
static void dev_unselect(spi_transaction_t* t);
static void dev_select(spi_transaction_t* t);
esp_err_t SPI_transmit(spi_transaction_t *t); 


void app_main() {


    ESP_ERROR_CHECK(nvs_flash_init());
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());

    vTaskDelay(2500 / portTICK_PERIOD_MS);

    xTaskCreate(&spi_task, "spi_task", 4096, NULL, 5, NULL);

}


static void spi_task(void *pvParameter) {

    esp_err_t ret;

    SPI_begin(GPIO_NUM_5);

    while (true) {

        spi_transaction_t t;
        //t.flags = SPI_TRANS_USE_TXDATA;
        t.cmd = 0xBA;
        t.addr = 0xCF;
        t.tx_buffer = NULL;
        t.rx_buffer = NULL;
        //t.length = 8;
        //t.rxlength = 2 * 8;

        ret = SPI_transmit(&t);

        //ESP_ERROR_CHECK(ret);

        vTaskDelay(1000 / portTICK_PERIOD_MS);
        
    }


}



esp_err_t SPI_begin(gpio_num_t pCS) {

    return SPI_begin1(VSPI_HOST, GPIO_MISO, GPIO_MOSI, GPIO_SCLK, pCS);

}

esp_err_t SPI_begin1(spi_host_device_t host, gpio_num_t pMOSI, gpio_num_t pMISO, gpio_num_t pCLK, gpio_num_t pCS) {

    esp_err_t ret;

    ESP_LOGI(spiTAG, "Iniciando bus SPI");
        
    spi_bus_config_t buscfg = {
        .mosi_io_num = pMOSI,
        .miso_io_num = pMISO,
        .sclk_io_num = pCLK,
        .quadwp_io_num = -1,
        .quadhd_io_num = -1,
        .max_transfer_sz = 4000
    };
 
    ret = spi_bus_initialize(host, &buscfg, 0);

    if (ret != ESP_OK) {
        ESP_LOGE(spiTAG, "No se pudo inicializar el bus SPI.");
        return ret;
    }
 
    //gpio_set_pull_mode(pMOSI, GPIO_PULLUP_ONLY);
    //gpio_set_pull_mode(pCLK, GPIO_PULLUP_ONLY);
    //gpio_set_pull_mode(pCS, GPIO_PULLUP_ONLY);

    ESP_LOGI(spiTAG, "Inicializando el dispositivo...");

    ctx = (spi_context_t*)malloc(sizeof(spi_context_t));
    if (!ctx) return ESP_ERR_NO_MEM;

    spi_config_t cfg = {
        .host = host,
        .cs = pCS,
        .miso = pMISO,
        .mosi = pMOSI,
        .clk = pCLK, 
        .intr_used = false
    };

    ctx->cfg = cfg;

    spi_device_interface_config_t devcfg;

    devcfg.flags = SPI_DEVICE_HALFDUPLEX;
    devcfg.command_bits = 0;
    devcfg.address_bits = 0;
    devcfg.clock_speed_hz = SPI_CLK_FREQ;
    devcfg.mode = 0;
    devcfg.spics_io_num = -1;
    devcfg.queue_size = 1;
    devcfg.pre_cb = dev_select;
    devcfg.post_cb = dev_unselect;

    //Attach the DEVICE to the SPI bus
    ret = spi_bus_add_device(ctx->cfg.host, &devcfg, &ctx->handle);

    if  (ret != ESP_OK) {

        if (!ctx->handle) {
            spi_bus_remove_device(ctx->handle);
            ctx->handle = NULL;
        }

        return ret;

    }


    gpio_set_level(ctx->cfg.cs, 0);

    gpio_config_t cs_cfg = {
        .pin_bit_mask = BIT64(ctx->cfg.cs),
        .mode = GPIO_MODE_OUTPUT,
    };
    gpio_config(&cs_cfg);



    gpio_config_t mosi_cfg = {
        .pin_bit_mask = BIT64(pMOSI),
        .mode = GPIO_MODE_OUTPUT,
    };
    gpio_config(&mosi_cfg);

    gpio_config_t miso_cfg = {
        .pin_bit_mask = BIT64(pMISO),
        .mode = GPIO_MODE_INPUT,
    };
    gpio_config(&miso_cfg);



    ESP_LOGI(spiTAG, "Dispositivo iniciado...");

    return ESP_OK;

}



esp_err_t SPI_transmit(spi_transaction_t *t) {

    t->user = ctx;

    ESP_LOGI(spiTAG, "Enviando datos...");

    esp_err_t ret =  spi_device_transmit(ctx->handle, t);

    ESP_LOGI(spiTAG, "Datos enviados.");


    return ret;

}


static void dev_unselect(spi_transaction_t* t)
{

    ESP_EARLY_LOGV("spi", "CS high %d.", ((spi_context_t*)t->user)->cfg.cs);
    gpio_set_level(((spi_context_t*)t->user)->cfg.cs, 1);

}

static void dev_select(spi_transaction_t* t)
{

    gpio_set_level(((spi_context_t*)t->user)->cfg.cs, 0);
    ESP_EARLY_LOGV("spi", "CS low %d.", ((spi_context_t*)t->user)->cfg.cs);

}


        

#ifdef __cplusplus
    }
#endif

Any idea?

Regards!