ESP32 Forum

ESP32 Official Forum
https://esp32.com/

SPI not workin, help needed

https://esp32.com/viewtopic.php?t=45300

Page 1 of 1

SPI not workin, help needed

Posted: Wed Apr 16, 2025 8:51 pm
by ivan.gerber
Hello, I'm having problems making the SPI communication to work, it stops mid-transfer...

My setup:
VSCode with Platformio, Espressif32 v6.10.0 using esp-idf
Microcontroller: ESP32S3
IC to communicate with via SPI: BL0942

I've made a very simple implementation, just to try out SPI master API, following this example code from esp-idf github repository:
This is my resulting test code:

Code: Select all

#include "bl0942.h"
#include <stdlib.h>
#include <string.h>
#include "esp_log.h"
#include "driver/spi_master.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/timers.h"

const char *TAG = "BL0942";
#define PIN_SPI_MOSI                        13
#define PIN_SPI_MISO                        11
#define PIN_SPI_SCK                         12

#define BL0942_REG_VOLTAGE                  0x08

bl0942_config_t *BL0942_PARAMS = nullptr;
spi_device_handle_t spi_bl0942_handle;

bl0942_status_t bl0942_spi_init(void);

bl0942_status_t bl0942_read_reg_spi(uint8_t reg_id, uint8_t *res, size_t size_reg);

bl0942_status_t bl0942_init(bl0942_config_t *config)
{
    if (config == nullptr)
    {
        ESP_LOGE(TAG, "%s - Null params", __func__);
        return BL0942_STATUS_ERR;
    }
    BL0942_PARAMS = config;
    if (bl0942_spi_init() != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error SPI init", __func__);
        return BL0942_STATUS_ERR;
    }
    ESP_LOGI(TAG, "%s - BL0942 initialized", __func__);
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_data(bl0942_data_t *data)
{
    if (data == nullptr)
    {
        ESP_LOGE(TAG, "%s - Null params", __func__);
        return BL0942_STATUS_ERR;
    }
    uint8_t buffer[4] = {0};
    //Read voltage value
    bl0942_read_reg_spi(BL0942_REG_VOLTAGE, buffer, sizeof(buffer));
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_spi_init(void)
{
    //Init the SPI bus
    spi_bus_config_t buscfg = {
        .mosi_io_num = PIN_SPI_MOSI,
        .miso_io_num = PIN_SPI_MISO,
        .sclk_io_num = PIN_SPI_SCK,
        .quadwp_io_num = -1,
        .quadhd_io_num = -1,
        .max_transfer_sz = 32,
    };
    esp_err_t ret = spi_bus_initialize(SPI2_HOST, &buscfg, SPI_DMA_CH_AUTO);
    ESP_ERROR_CHECK(ret);
    //Init device
    spi_device_interface_config_t devcfg = {
      .command_bits = 0,                        //No command bits
      .address_bits = 0,                        //No address bits
      .dummy_bits = 0,                          //No dummy bits
      .mode = 1,                                //SPI mode 1: CPOL=0 CPHA=1
      .clock_source = SPI_CLK_SRC_DEFAULT,      //Use APB clock
      .duty_cycle_pos = 128,                    //50% duty cycle
      .cs_ena_pretrans = 0,                     //No CS activation before transaction
      .cs_ena_posttrans = 0,                    //No CS deactivation after transaction
      .clock_speed_hz = 9 * 100 * 1000,         //Clock out at 900 kHz
      .input_delay_ns = 0,                      //No input delay
      .spics_io_num = 10,                       //CS pin
      .flags = 0,                               //No flags
      .queue_size = 7,                          //We want to be able to queue 7 transactions at a time
      .pre_cb = nullptr,                        //Specify pre-transfer callback to handle D/C line,
      .post_cb = nullptr
    };
    //add device to the bus
    ret = spi_bus_add_device(SPI2_HOST, &devcfg, &spi_bl0942_handle);
    if (ret != ESP_OK) {
      ESP_LOGE(TAG, "%s - Error to add SPI device to the bus: %s", __func__, esp_err_to_name(ret));
      return BL0942_STATUS_ERR;
    }
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_read_reg_spi(uint8_t reg_id, uint8_t *res, size_t size_reg)
{
    spi_transaction_t t;
    memset(&t, 0, sizeof(t));
    t.length = 32;
    t.tx_data[0] = reg_id;
    t.rxlength = 24;
    t.flags = SPI_TRANS_USE_TXDATA | SPI_TRANS_USE_RXDATA;
    if (spi_device_transmit(spi_bl0942_handle, &t) != ESP_OK)
    {
        ESP_LOGE(TAG, "%s - Error to read SPI register", __func__);
        return BL0942_STATUS_ERR;
    }
    ESP_LOGI(TAG, "%s - Data read: %02X%02X%02X%02X", __func__, t.rx_data[0], t.rx_data[1], t.rx_data[2], t.rx_data[3]);
    //Copy data
    memcpy(res, t.rx_data, size_reg);
    return BL0942_STATUS_OK;
}
Here is the esp32 logs of the firmware (you can see there are no errors in the initialization):
I (316) main_task: Started on CPU0
I (326) main_task: Calling app_main()
I (326) BL0942: bl0942_init - BL0942 initialized
I (326) BL0942: bl0942_read_reg_spi - Data read: FFFFFFFF
And here is what happens looking at the gpios with the logic analyzer:
Image

Is like the SPI lines don't work properly, I'm very confused.

I've tried to change various configurations to the device and the bus, I've followed the SPI connections for the SPI2_HOST pinout from the SPI Master Driver API reference

If someone has any input on this, perhaps very silly, problem I will appreciate it very much

Re: SPI not workin, help needed

Posted: Thu Apr 17, 2025 2:28 am
by Sprite
That feels like a sampling error. Are you sure the sampling rate of your LA is set to >=2MHz and the trigger threshold is set OK?

Re: SPI not workin, help needed

Posted: Fri Apr 18, 2025 1:05 pm
by ivan.gerber
Looks like my logic analyzer can't reach further than 500kS/s
Image

So I tried lowering the clock speed of the SPI device to 100kHz, same as I2C that I have already working with the logic analyzer.
This change made the singals appear correctly:
Image

I also had to fix some issues with the rx_buffer and the tx_buffer, I was not initializing them correctly. And some other fixes in the transmitted command to read data from the device correctly.

Thank you very much @Sprite !

Re: SPI not workin, help needed

Posted: Sat Aug 23, 2025 7:18 am
by ab-tools
Hello Ivan,

just accidentally found your thread here as I was searching for a SPI library for the BL0942.

Apparently, you are using the BL0942 via SPI, but I could only find a library for the BL0942 using UART.

Would you mind pointing to the SPI-based library you use or sharing your code for this?

Best regards and thanks in advance
Andreas

Re: SPI not workin, help needed

Posted: Mon Aug 25, 2025 1:25 pm
by ivan.gerber
Hello @ab-tools , I made an implementation of my own, it works for the moment, here it is, hope it helps you.

Code: Select all

#include "bl0942.h"
#include <stdlib.h>
#include <string.h>
#include "esp_log.h"
#include "driver/spi_master.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/timers.h"

const char *TAG = "BL0942";

#define BL0942_SPI_READ_CMD                 0x58
#define BL0942_SPI_WRITE_CMD                0xA8
#define BL0942_REG_VOLTAJE                  0x04

#define SIZE_REG_WAVE 20
#define SIZE_REG_RMS 24
#define SIZE_REG_WATT 24
#define SIZE_REG_CF_CNT 24
#define SIZE_REG_FREQ 16
#define SIZE_REG_STATUS 10
#define SIZE_REG_I_RMSOS 8
#define SIZE_REG_WA_CREEP 8
#define SIZE_REG_I_FAST_RMS_TH 16
#define SIZE_REG_I_FAST_RMS_CYC 3
#define SIZE_REG_FREQ_CYC 2
#define SIZE_REG_OT_FUNX 6
#define SIZE_REG_MODE 10
#define SIZE_REG_GAIN_CR 2
#define SIZE_REG_SOFT_RESET 24
#define SIZE_REG_USR_WRPROT 8

typedef enum{
    REG_I_WAVE = 0x01,
    REG_V_WAVE = 0x02,
    REG_I_RMS = 0x03,
    REG_V_RMS = 0x04,
    REG_I_FAST_RMS = 0x05,
    REG_WATT = 0x06,
    REG_CF_CNT = 0x07,
    REG_FREQ = 0x08,
    REG_STATUS = 0x09,
    REG_I_RMSOS = 0x12,
    REG_WA_CREEP = 0x14,
    REG_I_FAST_RMS_TH = 0x15,
    REG_I_FAST_RMS_CYC = 0x16,
    REG_FREQ_CYC = 0x17,
    REG_OT_FUNX = 0x18,
    REG_MODE = 0x19,
    REG_GAIN_CR = 0x1C,
    REG_SOFT_RESET = 0x1D,
    REG_USR_WRPROT = 0x1E,
}BL0942_REG_ID_t;

typedef enum{
    ACTIVE_ENERGY_CAL = 0,
    OVER_CURRENT_EVT,
    ZERO_CROSSIN_V,
    ZERO_CROSSIN_I,
}CF_FUN_t;

typedef union{
    uint8_t reg;
    struct{
        uint8_t cf1_fun:2;
        uint8_t cf2_fun:2;
        uint8_t zx_fun:2;
        uint8_t rest:2;
    } valores;
} CF_reg_t;

bl0942_config_t *BL0942_PARAMS = NULL;
spi_device_handle_t spi_bl0942_handle;

/**
 * @brief Inicializa el bus spi para el módulo BL0942
 * 
 * @return bl0942_status_t Estado de la inicialización
 */
bl0942_status_t bl0942_spi_init(void);
/**
 * @brief Leer registro del modulo BL0942
 * 
 * @param reg_id ID del registro a leer
 * @param res Puntero a la variable donde se guardará el resultado
 * @return opt3004_status_t Estado de la lectura
 */
bl0942_status_t bl0942_leer_reg_spi(BL0942_REG_ID_t reg_id, uint8_t *res, size_t size_reg);
/**
 * @brief Escribir registro del modulo BL0942
 * 
 * @param reg_id ID del registro a escribir
 * @param reg_val Valor a escribir
 * @return bl0942_status_t Estado de la escritura
 */
bl0942_status_t bl0942_escribir_reg_spi(uint8_t reg_id, uint8_t *reg_val);
/**
 * @brief Crear checksum de un buffer
 * 
 * @param buffer Buffer a chequear
 * @param size Tamaño del buffer
 * @return uint8_t Checksum invertido
 */
uint8_t bl0942_inv_checksum(uint8_t *buffer, size_t size);
bl0942_status_t bl0942_get_i_wave(uint8_t *res);
bl0942_status_t bl0942_get_v_wave(uint8_t *res);
bl0942_status_t bl0942_get_i_rms(float *current);
bl0942_status_t bl0942_get_v_rms(float *voltage);
bl0942_status_t bl0942_get_i_fast_rms(uint8_t *res);
bl0942_status_t bl0942_get_watt(float *power);
bl0942_status_t bl0942_get_cf_cnt(float *energy);
bl0942_status_t bl0942_get_freq(uint32_t *frequency);
bl0942_status_t bl0942_get_status(uint8_t *res);
bl0942_status_t bl0942_get_i_rmsos(uint8_t *res);
bl0942_status_t bl0942_get_wa_creep(uint8_t *res);
bl0942_status_t bl0942_get_i_fast_rms_th(uint8_t *res);
bl0942_status_t bl0942_get_i_fast_rms_cyc(uint8_t *res);
bl0942_status_t bl0942_get_freq_cyc(uint8_t *res);
bl0942_status_t bl0942_get_ot_funx(uint8_t *res);
bl0942_status_t bl0942_get_mode(uint8_t *res);
bl0942_status_t bl0942_get_gain_cr(uint8_t *res);
bl0942_status_t bl0942_get_soft_reset(uint8_t *res);
bl0942_status_t bl0942_get_usr_wrprot(uint8_t *res);

bl0942_status_t bl0942_init(bl0942_config_t *config)
{
    if (config == NULL)
    {
        ESP_LOGE(TAG, "%s - Parámetros nulos", __func__);
        return BL0942_STATUS_ERR;
    }
    BL0942_PARAMS = config;
    if (bl0942_spi_init() != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error de inicialización de host de SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_consumo(bl0942_data_t *data)
{
    if (data == NULL)
    {
        ESP_LOGE(TAG, "%s - Parámetros nulos", __func__);
        return BL0942_STATUS_ERR;
    }
    uint8_t res[6];
    float current, voltage, power, energy, power_factor;
    bzero(res, sizeof(res));
    if (bl0942_get_i_rms(&current) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer corriente", __func__);
        return BL0942_STATUS_ERR;
    }
    if (bl0942_get_v_rms(&voltage) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer voltaje", __func__);
        return BL0942_STATUS_ERR;
    }
    if (bl0942_get_watt(&power) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer potencia", __func__);
        return BL0942_STATUS_ERR;
    }
    if (bl0942_get_cf_cnt(&energy) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer energia", __func__);
        return BL0942_STATUS_ERR;
    }
    //Calcular factor de potencia
    //El factor de potencia se calcula como la potencia activa (W) dividida por el producto de la corriente (A) y el voltaje (V)
    if (current != 0) power_factor = power / (current * voltage);
    else power_factor = 0;
    ESP_LOGI(TAG, "%s - Corriente: %.3f mA, Voltaje: %.2f V, Potencia: %.2f W, Energia: %.4f kWh, Factor de Potencia: %.2f", __func__, current, voltage, power, energy, power_factor);
    data->current = current * 1000; //Convertir a mA
    data->voltage = voltage; //Voltaje en V
    data->power = power * 10; //Potencia en 0.1W
    data->energy = energy; //Energia en kWh
    power_factor = power_factor * 100.0f; //Convertir a porcentaje
    data->power_factor = (uint8_t)power_factor; //Factor de potencia
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_spi_init(void)
{
    //Init device
    spi_device_interface_config_t devcfg = {
      .command_bits = 0,                        //No command bits
      .address_bits = 0,                        //No address bits
      .dummy_bits = 0,                          //No dummy bits
      .mode = 1,                                //SPI mode 1: CPOL=0 CPHA=1
      .clock_source = SPI_CLK_SRC_DEFAULT,      //Use APB clock
      .duty_cycle_pos = 128,                    //50% duty cycle
      .cs_ena_pretrans = 0,                     //No CS activation before transaction
      .cs_ena_posttrans = 0,                    //No CS deactivation after transaction
      .clock_speed_hz = 1 * 100 * 1000,         //Clock out at 900 kHz
      .input_delay_ns = 0,                      //No input delay
      .spics_io_num = BL0942_PARAMS->cs_pin,    //CS pin
      .flags = 0,                               //No flags
      .queue_size = 7,                          //We want to be able to queue 7 transactions at a time
      .pre_cb = NULL,                        //Specify pre-transfer callback to handle D/C line,
      .post_cb = NULL
    };
    //Agregar el dispositivo al bus
    esp_err_t ret = spi_bus_add_device((spi_host_device_t)BL0942_PARAMS->spi_host_num, &devcfg, &spi_bl0942_handle);
    if (ret != ESP_OK) {
      ESP_LOGE(TAG, "%s - Error al agregar dispositivo al SPI: %s", __func__, esp_err_to_name(ret));
      return BL0942_STATUS_ERR;
    }
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_leer_reg_spi(BL0942_REG_ID_t reg_id, uint8_t *res, size_t size_reg)
{
    uint8_t cmd[6];
    cmd[0] = BL0942_SPI_READ_CMD; //Comando de lectura
    cmd[1] = (uint8_t)reg_id; //ID del registro a leer
    memset(cmd + 2, 0x00, sizeof(cmd) - 3);
    spi_transaction_t t;
    memset(&t, 0, sizeof(t));
    t.length = sizeof(cmd) * 8;
    t.tx_buffer = cmd;
    t.rxlength = size_reg * 8;
    t.rx_buffer = res;
    t.flags = 0;
    if (spi_device_transmit(spi_bl0942_handle, &t) != ESP_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    //Print received data
    // printf("Datos recibidos: ");
    // for (int i = 0; i < size_reg; i++)
    // {
    //     printf("%02X ", res[i]);
    // }
    // printf("\r\n");
    //Verificar checksum
    uint8_t data_verificar[5];
    memcpy(data_verificar, cmd, 2);
    memcpy(&data_verificar[2], &res[2], size_reg - 3);
    uint8_t checksum = bl0942_inv_checksum(data_verificar, sizeof(data_verificar));
    if (checksum != res[size_reg - 1])
    {
        ESP_LOGE(TAG, "%s - Error de checksum %d - %d", __func__, checksum, res[size_reg - 1]);
        return BL0942_STATUS_ERR;
    }
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_escribir_reg_spi(uint8_t reg_id, uint8_t *reg_val)
{
    uint8_t cmd[6], res[6];
    cmd[0] = BL0942_SPI_WRITE_CMD; //Comando de lectura
    cmd[1] = (uint8_t)reg_id; //ID del registro a leer
    memcpy(cmd + 2, reg_val, sizeof(cmd) - 3);
    uint8_t checksum = bl0942_inv_checksum(cmd, sizeof(cmd) - 1);
    cmd[sizeof(cmd) - 1] = checksum; //Checksum
    spi_transaction_t t;
    memset(&t, 0, sizeof(t));
    t.length = sizeof(cmd) * 8;
    t.tx_buffer = cmd;
    t.rxlength = sizeof(res) * 8;
    t.rx_buffer = res;
    t.flags = 0;
    if (spi_device_transmit(spi_bl0942_handle, &t) != ESP_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    return BL0942_STATUS_OK;
}

uint8_t bl0942_inv_checksum(uint8_t *buffer, size_t size)
{
    uint32_t temp = 0;
    for (int i = 0; i < size; i++)
    {
        temp += buffer[i];
    }
    uint8_t chks = temp & 0xFF;
    return ~chks;
}

bl0942_status_t bl0942_get_i_wave(uint8_t *res)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_I_WAVE, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    //Imprimir dato
    //ESP_LOGI(TAG, "I_WAVE: %ld", (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4]);
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_v_wave(uint8_t *res)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_V_WAVE, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    //Imprimir dato
    //ESP_LOGI(TAG, "V_WAVE: %ld", (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4]);
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_i_rms(float *current)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_I_RMS, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    uint32_t i_rms = (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4];
    float i_rms_f = (float)i_rms;
    //Convertir a amperes
    i_rms_f = i_rms_f * 0.0000015923f;
    //Imprimir dato
    //ESP_LOGI(TAG, "I_RMS: %f [A]", i_rms_f);
    *current = i_rms_f;
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_v_rms(float *voltage)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_V_RMS, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    uint32_t v_rms = (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4];
    //Convertir a volts
    float v_rms_f = (float)v_rms;
    v_rms_f = v_rms_f * 0.000164643f;
    //Imprimir dato
    //ESP_LOGI(TAG, "V_RMS: %f [V]", v_rms_f);
    *voltage = v_rms_f;
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_i_fast_rms(uint8_t *res)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_I_FAST_RMS, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    //Imprimir dato
    //ESP_LOGI(TAG, "I_FAST_RMS: %ld", (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4]);
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_watt(float *power)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_WATT, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    uint32_t watt = (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4];
    //Convertir a watts
    float watt_f = (float)watt;
    watt_f = watt_f * 0.00167772f;
    //Imprimir dato
    //ESP_LOGI(TAG, "WATT: %f [W]", watt_f);
    *power = watt_f;
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_cf_cnt(float *energy)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_CF_CNT, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    uint32_t cf_cnt;
    cf_cnt = (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4];
    //Convertir a Wh
    float cf_cnt_f = (float)cf_cnt;
    cf_cnt_f = cf_cnt_f * 0.0001954686f;
    //Imprimir dato
    //ESP_LOGI(TAG, "CF_CNT: %f [Wh]", cf_cnt_f);
    *energy = cf_cnt_f;
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_freq(uint32_t *frequency)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_FREQ, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    uint32_t freq = (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4];
    uint32_t freq_hz = 1000000 / freq; //Convertir a Hz
    //Imprimir dato
    //ESP_LOGI(TAG, "FREQ: %ld Hz", freq_hz);
    *frequency = freq_hz;
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_status(uint8_t *res)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_STATUS, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    //Imprimir dato
    //ESP_LOGI(TAG, "STATUS: %ld", (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4]);
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_i_rmsos(uint8_t *res)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_I_RMSOS, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    //Imprimir dato
    //ESP_LOGI(TAG, "I_RMSOS: %ld", (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4]);
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_wa_creep(uint8_t *res)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_WA_CREEP, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    //Imprimir dato
    //ESP_LOGI(TAG, "WA_CREEP: %ld", (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4]);
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_i_fast_rms_th(uint8_t *res)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_I_FAST_RMS_TH, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    //Imprimir dato
    //ESP_LOGI(TAG, "I_FAST_RMS_TH: %ld", (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4]);
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_i_fast_rms_cyc(uint8_t *res)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_I_FAST_RMS_CYC, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    //Imprimir dato
    //ESP_LOGI(TAG, "I_FAST_RMS_CYC: %ld", (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4]);
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_freq_cyc(uint8_t *res)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_FREQ_CYC, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    //Imprimir dato
    //ESP_LOGI(TAG, "FREQ_CYC: %ld", (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4]);
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_ot_funx(uint8_t *res)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_OT_FUNX, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    //Imprimir dato
    //ESP_LOGI(TAG, "OT_FUNX: %ld", (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4]);
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_mode(uint8_t *res)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_MODE, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    //Imprimir dato
    //ESP_LOGI(TAG, "MODE: %ld", (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4]);
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_gain_cr(uint8_t *res)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_GAIN_CR, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    //Imprimir dato
    //ESP_LOGI(TAG, "GAIN_CR: %ld", (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4]);
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_soft_reset(uint8_t *res)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_SOFT_RESET, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    //Imprimir dato
    //ESP_LOGI(TAG, "SOFT_RESET: %ld", (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4]);
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_get_usr_wrprot(uint8_t *res)
{
    uint8_t data[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_USR_WRPROT, data, sizeof(data)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    //Imprimir dato
    //ESP_LOGI(TAG, "USR_WRPROT: %ld", (uint32_t)data[2] << 16 | (uint32_t)data[3] << 8 | (uint32_t)data[4]);
    return BL0942_STATUS_OK;
}

bl0942_status_t bl0942_set_cf_zx_func(CF_FUN_t cf1, CF_FUN_t cf2, CF_FUN_t zx)
{
    CF_reg_t cf_reg;
    cf_reg.valores.cf1_fun = cf1;
    cf_reg.valores.cf2_fun = cf2;
    cf_reg.valores.zx_fun = zx;
    //Primero ver que el valor actual no sea el mismo
    uint8_t data_previo[6]; //2 cmd 3 data 1 checksum
    if (bl0942_leer_reg_spi(REG_OT_FUNX, data_previo, sizeof(data_previo)) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al leer registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    //Verificar si el valor es el mismo
    if (data_previo[2] == cf_reg.reg)
    {
        ESP_LOGI(TAG, "%s - Valor ya configurado", __func__);
        return BL0942_STATUS_OK;
    }
    //Escribir el nuevo valor
    uint8_t data[3];
    data[0] = 0x00; //No se usa
    data[1] = 0x00; //No se usa
    data[2] = cf_reg.reg; //Valor a escribir
    if (bl0942_escribir_reg_spi(REG_OT_FUNX, data) != BL0942_STATUS_OK)
    {
        ESP_LOGE(TAG, "%s - Error al escribir registro SPI", __func__);
        return BL0942_STATUS_ERR;
    }
    return BL0942_STATUS_OK;
}
Have in mind that I code in spanish/english, so you might have some issues with the understanding.

Re: SPI not workin, help needed

Posted: Tue Oct 14, 2025 8:12 am
by ab-tools
Hello Ivan,

just noticed that I forgot to reply.

Thanks a lot for providing your code, this definitely helped to get me going!

Best regards
Andreas
All times are UTC
Page 1 of 1
Powered by phpBB® Forum Software © phpBB Limited
https://www.phpbb.com/