BME280 and MAX17048 i2c problem

[qubyts]

Hi! I'm having problems initializing max17048. The problem is that as soon as i use "max1704x_quickstart(&dev)" the i2c driver fails to install and my esp32-c3 goes into a boot loop. If i don't use the "max1704x_quickstart(&dev)" the device doesn't initialise and nothing in my max.c file is logged, but the bme280 works as it should.
this is my max file.

`/*

• max.c
• Created on: May 2, 2024

•  Author: metap
  

*/

#include <driver/i2c.h>
#include <esp_err.h>
#include <hal/gpio_types.h>
#include <hal/i2c_types.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <freertos/event_groups.h>
#include <freertos/portmacro.h>
#include <freertos/projdefs.h>
#include <freertos/task.h>
#include "esp_log.h"
#include "esp_mac.h"
#include "esp_system.h"
#include "esp_event.h"
#include "esp_http_client.h"
#include <max1704x.h>
#include "driver/i2c_master.h"
#include "freertos/FreeRTOS.h"
#include <sys/socket.h>
#include "esp_http_client.h"

#define SERVER_URL "http://10.245.30.119:3000/insert-data"

static const char *MAX17048_TAG = "MAX17048";
#define SDA_PIN GPIO_NUM_0
#define SCL_PIN GPIO_NUM_1
TaskHandle_t max_reader_task_handle = NULL;

void max_reader_task(void *device_name_ptr){

float voltage = 0;
float soc_percent = 0;
float rate_change = 0;
max1704x_t max17048_dev = {0};

// Set up I2C bus to communicate with MAX17048
max17048_dev.model = MAX17048_9;

if (max1704x_init_desc(&max17048_dev, I2C_NUM_0, SDA_PIN, SCL_PIN) != ESP_OK)
{
	ESP_LOGE(MAX17048_TAG, "No not found");
}
else
{
	max1704x_get_voltage(&max17048_dev, &voltage);
	max1704x_get_soc(&max17048_dev, &soc_percent);
	max1704x_get_crate(&max17048_dev, &rate_change);

	if (voltage != 0 && soc_percent != 0 && rate_change != 0)
	{
		ESP_LOGI(MAX17048_TAG, "Voltage: %.2fV, SOC: %.2f%%, SOC rate of change: %.2f%%", voltage, soc_percent, rate_change);
	}
}

vTaskDelete(NULL);

}

void max_main(void)
{

xTaskCreate(max_reader_task, "max_reader_task", 4096, NULL, 5, NULL);

}

`

i then call the max_main function on my main file, where i also initialise i2c

`#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include <freertos/event_groups.h>
#include <freertos/portmacro.h>
#include <freertos/projdefs.h>
#include "esp_system.h"
#include "esp_mac.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "esp_bt.h"
#include "esp_sleep.h"
#include "driver/gpio.h"
#include <driver/i2c.h>
#include <esp_err.h>
#include <hal/gpio_types.h>
#include <hal/i2c_types.h>

#include "esp_blufi_api.h"
#include "ble.h"
#include "wifi.h"
#include "sensor_func.h"
#include <bme280.h>
#include "max1704x.h"
#include "esp_blufi.h"
#include "i2cdev.h"
#include "esp_idf_lib_helpers.h"
#include "sdkconfig.h"
#include "max.h"
#include "esp_console.h"

#define BLE_BUTTON GPIO_NUM_10
#define SDA_PIN GPIO_NUM_0
#define SCL_PIN GPIO_NUM_1
#define DEEP_SLEEP_PERIOD ((10 * 1000) / portTICK_PERIOD_MS) // 15 minutes in milliseconds
#define I2C_MASTER_NUM I2C_NUM_0
#define I2C_MASTER_FREQ_HZ 400000
#define I2C_MASTER_TX_BUF_DISABLE 0
#define I2C_MASTER_RX_BUF_DISABLE 0
#define WRITE_BIT I2C_MASTER_WRITE /!< I2C master write /
#define READ_BIT I2C_MASTER_READ /!< I2C master read /
#define ACK_CHECK_EN 0x1 /!< I2C master will check ack from slave/
#define ACK_CHECK_DIS 0x0 /*!< I2C master will not check ack from slave /
#define ACK_VAL 0x0 /!< I2C ack value /
#define NACK_VAL 0x1 /!< I2C nack value */

volatile int value = 0;
volatile bool nvs_cleared = false;
volatile bool button_pressed = false;
volatile bool switch_case = false; // false for WiFi, true for BLUFI

void clear_nvs_partition() {
if (!nvs_cleared) {
esp_err_t ret;

	// Erase the NVS partition
	ret = nvs_flash_erase();
	if (ret != ESP_OK) {
		printf("Error erasing NVS partition\n");
		return;
	}

	// Reinitialize the NVS partition
	ret = nvs_flash_init();
	if (ret != ESP_OK) {
		printf("Error initializing NVS partition\n");
		return;
	}

	printf("NVS partition cleared successfully\n");
	nvs_cleared = true; // Set the flag to true after clearing NVS
}

}

void switch_mode() {
switch_case = !switch_case; // Toggle the mode

if (switch_case) {

	//clear_nvs_partition();
	blufi_func();
	// Ensure Bluetooth is initialized and enabled before continuing
	vTaskDelay(10 / portTICK_PERIOD_MS);
	printf("Switched to BLUFI mode\n");
} else {
	// Disable Bluetooth to save power
	ble_deinit();
	vTaskDelay(10 / portTICK_PERIOD_MS);

	if (is_wifi_connected()) {
		ESP_LOGI("WiFi", "ESP32 is connected to WiFi");
	} else {
		ESP_LOGI("WiFi", "ESP32 is not connected to WiFi");
	}
	printf("Switched to WiFi mode\n");
}

}

void button_callback(void* arg) {
button_pressed = true;
}

int do_i2cdetect_cmd(int argc, char **argv);

void i2c_master_init()
{
i2c_config_t conf = {
.mode = I2C_MODE_MASTER,
.sda_io_num = SDA_PIN,
.scl_io_num = SCL_PIN,
.sda_pullup_en = GPIO_PULLUP_ENABLE,
.scl_pullup_en = GPIO_PULLUP_ENABLE,
.master.clk_speed = I2C_MASTER_FREQ_HZ
};
ESP_ERROR_CHECK(i2c_param_config(I2C_MASTER_NUM, &conf));
ESP_ERROR_CHECK(i2c_driver_install(I2C_MASTER_NUM, conf.mode, I2C_MASTER_RX_BUF_DISABLE, I2C_MASTER_TX_BUF_DISABLE, 0));

esp_console_cmd_t i2cdetect_cmd = {
    .command = "i2cdetect",
    .help = "Scan I2C bus for devices",
    .hint = NULL,
    .func = &do_i2cdetect_cmd,
    .argtable = NULL
};
ESP_ERROR_CHECK(esp_console_cmd_register(&i2cdetect_cmd));

}

int do_i2cdetect_cmd(int argc, char **argv) {
printf(" 0 1 2 3 4 5 6 7 8 9 a b c d e f\n");
for (int i = 0; i < 128; i += 16) {
printf("%02x: ", i);
for (int j = 0; j < 16; j++) {
int ret;
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
i2c_master_start(cmd);
i2c_master_write_byte(cmd, (i + j) << 1 | WRITE_BIT, ACK_CHECK_EN);
i2c_master_stop(cmd);
ret = i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 10 / portTICK_PERIOD_MS);
i2c_cmd_link_delete(cmd);

        if (ret == ESP_OK) {
            printf("%02x ", i + j);
        } else if (ret == ESP_ERR_TIMEOUT) {
            printf("UU ");
        } else {
            printf("-- ");
        }
    }
    printf("\n");
}
return 0;

}

void app_main(void) {

gpio_config_t io_conf;
io_conf.intr_type = GPIO_INTR_NEGEDGE;
io_conf.pin_bit_mask = (1ULL << BLE_BUTTON);
io_conf.mode = GPIO_MODE_INPUT;
io_conf.pull_up_en = GPIO_PULLUP_ENABLE;
gpio_config(&io_conf);

gpio_install_isr_service(0);
gpio_isr_handler_add(BLE_BUTTON, button_callback, NULL);

wifi_on();

i2c_master_init();

vTaskDelay(1000 / portTICK_PERIOD_MS);

if (is_wifi_connected()) {
	ESP_LOGI("WiFi", "ESP32 is connected to WiFi");
} else {
	ESP_LOGI("WiFi", "ESP32 is not connected to WiFi");
	button_pressed = true;
}
max_main();

bme280_sensor_func("myname");

while (1) {
	if (button_pressed) {
		switch_mode(); // Handle mode switching
		button_pressed = false; // Reset button flag
	}


	if (switch_case) {
		// BLUFI mode: broadcast and continue without entering idle
		vTaskDelay(100 / portTICK_PERIOD_MS); // Delay to avoid high CPU usage
	} else {
		// WiFi mode: enter deep sleep for 15 minutes

		vTaskDelay(1000 / portTICK_PERIOD_MS); // Delay to allow for other tasks
		printf("Entering deep sleep for 15 minutes...\n");
	}
}

}

`
I also have a bme280 running with the official library

`/*

• sensor_func.c
• Created on: 2 Feb 2024

•  Author: metap
  

*/
#include <bme280.h>
#include <driver/i2c.h>
#include <esp_err.h>
#include <hal/gpio_types.h>
#include <hal/i2c_types.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <freertos/event_groups.h>
#include <freertos/portmacro.h>
#include <freertos/projdefs.h>
#include <freertos/task.h>
#include "sensor_func.h"
#include "esp_log.h"
#include "esp_http_client.h"
#include <max1704x.h>

#define SERVER_URL "http://10.245.30.119:3000/insert-data"

#define SDA_PIN GPIO_NUM_0
#define SCL_PIN GPIO_NUM_1
#define TAG_BME280 "BME280"
#define I2C_MASTER_ACK 0
#define I2C_MASTER_NACK 1

volatile double temp = 0.0;
volatile double hum = 0.0;
volatile double press = 0.0;
volatile bool data_ready = false; // Flag to indicate new data is ready

s8 BME280_I2C_bus_write(u8 dev_addr, u8 reg_addr, u8 *reg_data, u8 cnt)
{
s32 iError = BME280_INIT_VALUE;

esp_err_t espRc;
i2c_cmd_handle_t cmd = i2c_cmd_link_create();

i2c_master_start(cmd);
i2c_master_write_byte(cmd, (dev_addr << 1) | I2C_MASTER_WRITE, true);

i2c_master_write_byte(cmd, reg_addr, true);
i2c_master_write(cmd, reg_data, cnt, true);
i2c_master_stop(cmd);

espRc = i2c_master_cmd_begin(I2C_NUM_0, cmd, 10/portTICK_PERIOD_MS);

if (espRc == ESP_OK) {
	iError = SUCCESS;
} else {
	iError = ERROR;
}

i2c_cmd_link_delete(cmd);

return (s8)iError;

}

s8 BME280_I2C_bus_read(u8 dev_addr, u8 reg_addr, u8 *reg_data, u8 cnt)
{
s32 iError = BME280_INIT_VALUE;
esp_err_t espRc;

i2c_cmd_handle_t cmd = i2c_cmd_link_create();

i2c_master_start(cmd);
i2c_master_write_byte(cmd, (dev_addr << 1) | I2C_MASTER_WRITE, true);
i2c_master_write_byte(cmd, reg_addr, true);

i2c_master_start(cmd);
i2c_master_write_byte(cmd, (dev_addr << 1) | I2C_MASTER_READ, true);

if (cnt > 1) {
	i2c_master_read(cmd, reg_data, cnt-1, I2C_MASTER_ACK);
}
i2c_master_read_byte(cmd, reg_data+cnt-1, I2C_MASTER_NACK);
i2c_master_stop(cmd);

espRc = i2c_master_cmd_begin(I2C_NUM_0, cmd, 10/portTICK_PERIOD_MS);

if (espRc == ESP_OK) {
	iError = SUCCESS;
} else {
	iError = ERROR;
}


i2c_cmd_link_delete(cmd);

return (s8)iError;

}

void BME280_delay_msek(u32 msek)
{
vTaskDelay(msek/portTICK_PERIOD_MS);
}

void send_data_http(double temperature, double humidity) {
esp_http_client_config_t config = {
.url = SERVER_URL,
};
esp_http_client_handle_t client = esp_http_client_init(&config);
if (client == NULL) {
ESP_LOGE(TAG_BME280, "Failed to initialize HTTP client");
return;
}

char post_data[200];
snprintf(post_data, sizeof(post_data), "temperature=%.2f&humidity=%.3f", temperature, humidity);

esp_http_client_set_method(client, HTTP_METHOD_POST);
esp_http_client_set_post_field(client, post_data, strlen(post_data));

esp_err_t err = esp_http_client_perform(client);
if (err != ESP_OK) {
	ESP_LOGE(TAG_BME280, "HTTP request failed: %s", esp_err_to_name(err));
}

esp_http_client_cleanup(client);

}

void bme_reading(void pvParameters)
{
/ --------------------------------------- INIT BME280 -------------------------------------- */
struct bme280_t bme280 = {
.bus_write = BME280_I2C_bus_write,
.bus_read = BME280_I2C_bus_read,
.dev_addr = BME280_I2C_ADDRESS1,
.delay_msec = BME280_delay_msek
};

    s32 com_rslt;
    s32 v_uncomp_pressure_s32;
    s32 v_uncomp_temperature_s32;
    s32 v_uncomp_humidity_s32;

    com_rslt = bme280_init(&bme280);

    com_rslt += bme280_set_oversamp_pressure(BME280_OVERSAMP_16X);
    com_rslt += bme280_set_oversamp_temperature(BME280_OVERSAMP_2X);
    com_rslt += bme280_set_oversamp_humidity(BME280_OVERSAMP_1X);

    com_rslt += bme280_set_standby_durn(BME280_STANDBY_TIME_1_MS);
    com_rslt += bme280_set_filter(BME280_FILTER_COEFF_16);

    com_rslt += bme280_set_power_mode(BME280_NORMAL_MODE);
    if (com_rslt == SUCCESS) {
            while(true) {
                vTaskDelay(500/portTICK_PERIOD_MS);

                com_rslt = bme280_read_uncomp_pressure_temperature_humidity(
                        &v_uncomp_pressure_s32, &v_uncomp_temperature_s32, &v_uncomp_humidity_s32);

                if (com_rslt == SUCCESS) {
                    double temp_comp = bme280_compensate_temperature_double(v_uncomp_temperature_s32);
                    double press_comp = bme280_compensate_pressure_double(v_uncomp_pressure_s32) / 100;
                    double hum_comp = bme280_compensate_humidity_double(v_uncomp_humidity_s32);

                    ESP_LOGI(TAG_BME280, "%.2f degC / %.3f hPa / %.3f %%",
                            temp_comp, press_comp, hum_comp);

                    // Send sensor data over HTTP
                    send_data_http(temp_comp, hum_comp);


                    // Update global variables
                    temp = temp_comp;
                    press = press_comp;
                    hum = hum_comp;
                    data_ready = true; // Indicate new data is ready

                } else {
                               ESP_LOGE(TAG_BME280, "measure error. code: %d", com_rslt);
                           }
                       }
                   } else {
                       ESP_LOGE(TAG_BME280, "init or setting error. code: %d", com_rslt);
                   }






vTaskDelete(NULL);

}

void bme280_sensor_func(const char *device_name)
{

/* ---------------------------------- SENSOR MEASUREMENTS ----------------------------------- */
ESP_ERROR_CHECK(i2cdev_init());
xTaskCreate(bme_reading, "bme_reading", 4096, NULL, 5, NULL);

}

`

[qubyts]

sorry for the long post, i appreciate any help.