ESP32 Forum

Code: Select all

#include "i2c_init.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "driver/gpio.h"

i2c_master_bus_handle_t vl53l0x_i2c_bus;

void init_i2c_master_vl53l0x(void) {
    const i2c_master_bus_config_t i2c_config = {
        .clk_source = I2C_CLK_SRC_DEFAULT,
        .i2c_port = I2C_NUM_0,
        .sda_io_num = VL53L0X_SDA_GPIO,
        .scl_io_num = VL53L0X_SCL_GPIO,
        .glitch_ignore_cnt = 7,
        .flags.enable_internal_pullup = true,
    };

    ESP_ERROR_CHECK(i2c_new_master_bus(&i2c_config, &vl53l0x_i2c_bus));
    ESP_LOGI("I2C_INIT", "VL53L0X I2C master bus initialized on port 0 (SDA=%d, SCL=%d)", VL53L0X_SDA_GPIO, VL53L0X_SCL_GPIO);
}

void vl53l0x_hard_reset(void) {
    gpio_config_t io_conf = {
        .pin_bit_mask = (1ULL << VL53L0X_XSHUT_GPIO),
        .mode = GPIO_MODE_OUTPUT,
        .pull_up_en = true,
        .pull_down_en = false,
        .intr_type = GPIO_INTR_DISABLE,
    };

    gpio_config(&io_conf);

    gpio_set_level(VL53L0X_XSHUT_GPIO, 0); // Hold reset
    vTaskDelay(pdMS_TO_TICKS(10));
    gpio_set_level(VL53L0X_XSHUT_GPIO, 1); // Power up
    vTaskDelay(pdMS_TO_TICKS(10));        // Wait for boot
    ESP_LOGI("I2C_INIT", "VL53L0X XSHUT toggled HIGH");
}

Code: Select all

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "vl53l0x_api.h"
#include "vl53l0x_platform.h"
#include "vl53l0x_platform_log.h"
#include "driver/gpio.h"
#include "tcp_server.h"  // for `global_sock`
#include "lwip/sockets.h"
#include "i2c_init.h"  // for `init_i2c_master_vl53l0x()`

#define XSHUT_GPIO GPIO_NUM_3
#define TAG "VL53L0X_TASK"
#define VL53L0X_I2C_ADDR 0x29

VL53L0X_Dev_t sensor_dev;
VL53L0X_DEV dev = &sensor_dev;

void vl53l0x_task(void *pvParameters) {
    VL53L0X_RangingMeasurementData_t measurement;
    VL53L0X_Error status;

    // Init XSHUT pin
    gpio_reset_pin(XSHUT_GPIO);
    gpio_set_direction(XSHUT_GPIO, GPIO_MODE_OUTPUT);
    gpio_set_level(XSHUT_GPIO, 1);  // Power on

    vTaskDelay(pdMS_TO_TICKS(10));  // Stabilize

    dev->I2cDevAddr = 0x29;
    dev->comms_type = 1;
    dev->comms_speed_khz = 50;

    status = VL53L0X_WaitDeviceBooted(dev);
    if (status != VL53L0X_ERROR_NONE) {
        ESP_LOGE(TAG, "Device boot wait failed: %d", status);
        vTaskDelete(NULL);
    }
    ESP_LOGI("VL53L0X_TASK", "Probing sensor at address 0x%02X...", VL53L0X_I2C_ADDR);

    status = VL53L0X_DataInit(dev);
    if (status != VL53L0X_ERROR_NONE) {
        ESP_LOGE(TAG, "DataInit failed: %d", status);
        vTaskDelete(NULL);
    }

    status = VL53L0X_StaticInit(dev);
    if (status != VL53L0X_ERROR_NONE) {
        ESP_LOGE(TAG, "StaticInit failed: %d", status);
        vTaskDelete(NULL);
    }

    status = VL53L0X_PerformRefCalibration(dev, NULL, NULL);
    if (status != VL53L0X_ERROR_NONE) {
        ESP_LOGE(TAG, "Calibration failed: %d", status);
        vTaskDelete(NULL);
    }

    status = VL53L0X_SetDeviceMode(dev, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING);
    if (status != VL53L0X_ERROR_NONE) {
        ESP_LOGE(TAG, "SetMode failed: %d", status);
        vTaskDelete(NULL);
    }

    status = VL53L0X_StartMeasurement(dev);
    if (status != VL53L0X_ERROR_NONE) {
        ESP_LOGE(TAG, "StartMeasurement failed: %d", status);
        vTaskDelete(NULL);
    }

    ESP_LOGI(TAG, "VL53L0X running...");
    ESP_LOGI("VL53L0X_TASK", "Starting VL53L0X task");

    char packet[64];

    while (1) {
        status = VL53L0X_GetRangingMeasurementData(dev, &measurement);
        if (status == VL53L0X_ERROR_NONE) {
            uint16_t distance = measurement.RangeMilliMeter;
            ESP_LOGI(TAG, "Distance: %d mm", distance);

            if (global_sock != -1) {
                snprintf(packet, sizeof(packet), "[TOF] %d\n", distance);
                send(global_sock, packet, strlen(packet), 0);
            }

            VL53L0X_ClearInterruptMask(dev, 0);
        } else {
            ESP_LOGW(TAG, "Failed to read measurement: %d", status);
        }
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

Code: Select all

static i2c_master_dev_handle_t vl53l0x_dev_handle = NULL;

// Initialize I2C communication (call this first)
int32_t VL53L0X_platform_init(i2c_master_bus_handle_t bus_handle, uint8_t address) {
    i2c_device_config_t dev_cfg = {
        .device_address = address,
        .scl_speed_hz = 100000,
        .dev_addr_length = I2C_ADDR_BIT_LEN_7,
    };
    
    esp_err_t ret = i2c_master_bus_add_device(bus_handle, &dev_cfg, &vl53l0x_dev_handle);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Failed to add I2C device: %s", esp_err_to_name(ret));
        return -1;
    }
    return 0;
}

// Common transmit function
static int32_t vl53l0x_transmit(uint8_t *data, size_t size) {
    if (!vl53l0x_dev_handle) return -1;
    esp_err_t ret = i2c_master_transmit(vl53l0x_dev_handle, data, size, VL53L0X_DEFAULT_TIMEOUT_MS);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Transmit failed: %s", esp_err_to_name(ret));
        return -1;
    }
    return 0;
}

// Common receive function
static int32_t vl53l0x_receive(uint8_t *tx_data, size_t tx_len, uint8_t *rx_data, size_t rx_len) {
    if (!vl53l0x_dev_handle) return -1;
    esp_err_t ret = i2c_master_transmit_receive(vl53l0x_dev_handle, 
                                              tx_data, tx_len, 
                                              rx_data, rx_len, 
                                              VL53L0X_DEFAULT_TIMEOUT_MS);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Transmit-receive failed: %s", esp_err_to_name(ret));
        return -1;
    }
    return 0;
}

// ST API required functions
int32_t VL53L0X_write_multi(uint8_t address, uint8_t reg, uint8_t *pdata, int32_t count) {
    uint8_t buffer[count + 1];
    buffer[0] = reg;
    memcpy(&buffer[1], pdata, count);
    return vl53l0x_transmit(buffer, count + 1);
}