SPI not workin, help needed

[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:


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

[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?

[ivan.gerber]

Looks like my logic analyzer can't reach further than 500kS/s


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:


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 !

[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

[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.

[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