ESP32 s3 super mini No SPI output

[GrayFox69]

I created a custom DRV8912-Q board and wanted to controll it directly via ESP32 SPI. I wrote all the code and uploaded it checked that all of the wiers are correctly soldered and that the ESP32 board MUX pins for SPI are 10,11,12,13.
But when I checked with an osciloscope there was no change on any of the SPI wiers.
Here is the code:

#include <stdio.h>
#include <string.h>
#include <driver/gpio.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <driver/spi_master.h>
#include <esp_log.h>

// Definējam pinu konfigurāciju
#define CSO_PIN    10
#define MOSI_PIN   11
#define SCLK_PIN   12
#define MISO_PIN   13
#define NSLEEP_PIN 9   // nSLEEP vadības tapa
#define NFAULT_PIN 8   // nFAULT ieeja

static const char *TAG = "DRV8912_CTRL";
spi_device_handle_t drv_spi_handle;

// Funkcija reģistra nolasīšanai
uint8_t drv8912_read_reg(uint8_t addr) {
    spi_transaction_t t;
    memset(&t, 0, sizeof(t));

    // B15=0, B14=1 (Read), B13-B8=Adrese
    uint16_t tx_val = (1 << 14) | ((uint16_t)(addr & 0x3F) << 8);

    t.length = 16;
    t.flags = SPI_TRANS_USE_TXDATA | SPI_TRANS_USE_RXDATA;
    t.tx_data[0] = (tx_val >> 8) & 0xFF;
    t.tx_data[1] = 0x00;

    esp_err_t ret = spi_device_transmit(drv_spi_handle, &t);
    if (ret != ESP_OK) {
        return 0;
    }

    // Otrā saņemtā baita vērtība ir reģistra saturs
    return t.rx_data[1];
}

/**
 * Nolasa un izpilda visu reģistru debug izdruku
 */
void drv8912_read_all_registers() {
    printf("\n--- DRV8912 REĢISTRU KARTE ---\n");
    printf("ADR | NOSAUKUMS       | VĒRTĪBA\n");
    printf("-------------------------------\n");

    uint8_t regs[] = {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
        0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,       
        0x0F, 0x10, 0x11, 0x12,                         
        0x13, 0x14, 0x15, 0x16,                         
        0x17, 0x18, 0x19, 0x1A, 0x1B, 0x24              
    };

    const char* names[] = {
        "IC_STAT", "OCP_STAT_1", "OCP_STAT_2", "OCP_STAT_3", 
        "OLD_STAT_1", "OLD_STAT_2", "OLD_STAT_3", "CONFIG_CTRL",
        "OP_CTRL_1", "OP_CTRL_2", "OP_CTRL_3", "PWM_CTRL_1", 
        "PWM_CTRL_2", "FW_CTRL_1", "FW_CTRL_2", "PWM_MAP_1", 
        "PWM_MAP_2", "PWM_MAP_3", "PWM_FREQ", "DUTY_CH1", 
        "DUTY_CH2", "DUTY_CH3", "DUTY_CH4", "SR_CTRL_1", 
        "SR_CTRL_2", "OLD_CTRL_1", "OLD_CTRL_2", "OLD_CTRL_3", "OLD_CTRL_4"
    };

    for (int i = 0; i < sizeof(regs); i++) {
        uint8_t val = drv8912_read_reg(regs[i]);
        printf("0x%02X | %-15s | 0x%02X\n", regs[i], names[i], val);
    }
    printf("-------------------------------\n\n");
}

// Funkcija rakstīšanai DRV8912 reģistros (16-bitu formāts)
void drv8912_write_reg(uint8_t addr, uint8_t data) {
    spi_transaction_t t;
    memset(&t, 0, sizeof(t));

    // B15=0, B14=0 (Write), B13-B8=Adrese, B7-B0=Dati
    uint16_t tx_val = ((uint16_t)(addr & 0x3F) << 8) | data;

    t.length = 16;
    t.flags = SPI_TRANS_USE_TXDATA | SPI_TRANS_USE_RXDATA;
    t.tx_data[0] = (tx_val >> 8) & 0xFF;
    t.tx_data[1] = tx_val & 0xFF;

    esp_err_t ret = spi_device_transmit(drv_spi_handle, &t);
    
    if (ret == ESP_OK) {
        uint8_t status = t.rx_data[0]; // SDO pirmais baits satur IC statusu
        uint8_t report = t.rx_data[1]; // SDO otrais baits satur report
        if (status != 0x00 && status != 0xFF) {
            // Logojam, ja statuss ziņo par kļūdām (piem. OTSD vai OCP)
            ESP_LOGI(TAG, "Pierakstīts 0x%02X -> Reģistrs 0x%02X || IC Statuss: 0x%02X, IC report: 0x%02X", data, addr, status, report);
        }
    } else {
        ESP_LOGE(TAG, "SPI sūtīšanas kļūda!");
    }
}

void app_main(void) {
    // 1. nSLEEP un nFAULT GPIO inicializācija
    gpio_set_direction(NSLEEP_PIN, GPIO_MODE_OUTPUT);
    gpio_set_level(NSLEEP_PIN, 0); // Sākumā Sleep mode
    
    gpio_set_direction(NFAULT_PIN, GPIO_MODE_INPUT);

    // Pamodinām ierīci
    ESP_LOGI(TAG, "Waking up DRV8912...");
    gpio_set_level(NSLEEP_PIN, 1);
    
    // t_WAKE aizture - obligāta, lai SPI kļūtu aktīvs
    vTaskDelay(pdMS_TO_TICKS(50)); 
    
    // 2. SPI Busa konfigurācija
    spi_bus_config_t buscfg = {
        .mosi_io_num = MOSI_PIN,
        .miso_io_num = MISO_PIN,
        .sclk_io_num = SCLK_PIN,
        .quadwp_io_num = -1,
        .quadhd_io_num = -1,
        .max_transfer_sz = 32,
    };

    // 3. Ierīces specifiskā konfigurācija
    spi_device_interface_config_t devcfg = {
        .clock_speed_hz = 5000000,           // 1 MHz
        .mode = 1,                           // SPI Mode 1 (Falling edge capture)
        .spics_io_num = CSO_PIN,
        .queue_size = 7,
        .cs_ena_posttrans = 1,               // nSCS HIGH pauze >400ns
    };

    ESP_ERROR_CHECK(spi_bus_initialize(SPI2_HOST, &buscfg, SPI_DMA_CH_AUTO));
    ESP_ERROR_CHECK(spi_bus_add_device(SPI2_HOST, &devcfg, &drv_spi_handle));

    ESP_LOGI(TAG, "SPI Master inicializēts. Sākam vadību...");

    

    // 1. Pamodinām čipu
    gpio_set_level(NSLEEP_PIN, 1);
    vTaskDelay(pdMS_TO_TICKS(500));
    gpio_set_level(NSLEEP_PIN, 1);
    
    ESP_LOGI(TAG, "Faults cleared.");
    // 2. Kļūdu dzēšana (CLR_FLT = 1 reģistrā 0x07)
    drv8912_write_reg(0x07, 0x01);
    vTaskDelay(pdMS_TO_TICKS(10));
    // 3. Pārbaudām reālo statusu
    uint8_t final_stat = drv8912_read_reg(0x00);
    if (final_stat == 0x00) {
        ESP_LOGI(TAG, "DRV8912 ir tīrs un gatavs!");
    } else {
        ESP_LOGW(TAG, "Statuss pēc dzēšanas: 0x%02X. Pārbaudi barošanu (VM).", final_stat);
    }
    // 4. Ierīces konfigurācija
    vTaskDelay(pdMS_TO_TICKS(100));
    drv8912_write_reg(0x07, 0x01);
    vTaskDelay(pdMS_TO_TICKS(100));
    drv8912_write_reg(0x0F, 0xFF); //set HB 1-4 to chanel 4 PWM
    vTaskDelay(pdMS_TO_TICKS(100));
    drv8912_write_reg(0x10, 0xFF); //set HB 5-8 to chanel 4 PWM
    vTaskDelay(pdMS_TO_TICKS(100));
    drv8912_write_reg(0x11, 0xFF); //set HB 9-12 to chanel 4 PWM
    vTaskDelay(pdMS_TO_TICKS(100));
    drv8912_write_reg(0x12, 0x00); // PWM freq
    vTaskDelay(pdMS_TO_TICKS(100));
    drv8912_write_reg(0x0B, 0x07); //set HB 1-8 to PWM mode
    vTaskDelay(pdMS_TO_TICKS(100));
    drv8912_write_reg(0x0C, 0x0F); //set HB 9-12 to PWM mode and enable chanel 4
    vTaskDelay(pdMS_TO_TICKS(100));
    drv8912_write_reg(0x17, 0xFF); // Slew rate
    vTaskDelay(pdMS_TO_TICKS(100));
    drv8912_write_reg(0x18, 0x07); // Slew rate
    vTaskDelay(pdMS_TO_TICKS(100));
    drv8912_write_reg(0x19, 0xFF); // Disable OLD
    vTaskDelay(pdMS_TO_TICKS(100));
    drv8912_write_reg(0x1A, 0x4F); // Disable OLD
    vTaskDelay(pdMS_TO_TICKS(100));
    drv8912_write_reg(0x08, 0x6A); // HB1,2,3 HS; HB4 LS
    vTaskDelay(pdMS_TO_TICKS(100));
    drv8912_write_reg(0x09, 0x05); // HB5,6 LS
    vTaskDelay(pdMS_TO_TICKS(100));

    uint8_t i =0;
    while (1) {
        // Atjaunojam Duty vērtību CH4
        drv8912_write_reg(0x16, 0x80);
        int nFault = gpio_get_level(NFAULT_PIN);
        if (nFault == 0) {
            ESP_LOGW(TAG, "KĻŪDA: nFAULT līnija ir LOW!");
        }
        

        if(i==100) {
            drv8912_read_all_registers();
            i=0;
        }
        vTaskDelay(pdMS_TO_TICKS(1000));
        i++;
    }
}

And the custom board schematic where SPI pins are connected accordingly, NFault is latched high and connected to other ESP32 pins for fault detection and NSleep is latched high by the ESP32 I/O functions, it wakes up the 12 halfbridge chip.

And the chips documentation in short it should recive a 16 bit command where first bite is addres for the registers and the second bite is for the data to be writen, it starts accepting data when CS pin is latched low and the data red from SCLK low side. The chip supports up to 5MHz SPI: [C1855817.pdf](https://github.com/user-attachments/files/24652027/C1855817.pdf)

I Have tried different pins and tweking the code to hell but nothing works, one other thing the terminal when connected to esp32 while powered on shows that its sending data and reading registers but the 12 h-bridge driver is not reacting and there is no voltage on the motor side pins.

P.S.
Sorry some of the parts, mainly sentences printed in terminal, are in Latvian

[Oliver2003Taylor]

The fundamental point you are missing here is to understand that in the Arduino-ESP32 core, the USB interface on ESP32-S3 is hard-wired to act as the Serial/REPL console by default, so it can’t be reused for PPP at the same time.

If you want PPP over USB, you’ll need to disable USB CDC for logging and move the console to a UART, then use TinyUSB (USB-NET / CDC-ECM or RNDIS) instead. The Arduino core doesn’t expose this cleanly yet, so this is much easier in ESP-IDF, where CONFIG_ESP_CONSOLE_USB_CDC can be turned off and USB networking enabled explicitly. So this isn’t a hardware issue — it’s a limitation of the Arduino core’s USB stack. For PPP/USB networking, ESP-IDF is currently the practical path.