common.c

Go to the documentation of this file.

/** \file common.c
 *
 * \brief Common utility functions and definitions for the BME68X sensor interface
 *
 * \copyright (c) 2023 Bosch Sensortec GmbH. All rights reserved.
 *
 * \note SPDX-License-Identifier: BSD-3-Clause
 *
 */
 
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <zephyr/drivers/i2c.h>
 
#include "bme68x.h"
// #include "coines.h"
#include "common.h"
#include "jfet_common.h"
 
/******************************************************************************/
/*!                 Macro definitions                                         */
#define BME68X_SHUTTLE_ID 0x93 //!< BME68X shuttle board ID
 
/******************************************************************************/
/*!                Static variable definition                                 */
static uint8_t dev_addr;
 
#if 0
/******************************************************************************/
/*!                User interface functions                                   */
 
/*!
 * I2C read function map to COINES platform
 */
BME68X_INTF_RET_TYPE bme68x_i2c_read(uint8_t reg_addr, uint8_t *reg_data, uint32_t len, void *intf_ptr)
{
    uint8_t device_addr = *(uint8_t*)intf_ptr;
 
    (void)intf_ptr;
 
    return coines_read_i2c(COINES_I2C_BUS_0, device_addr, reg_addr, reg_data, (uint16_t)len);
}
 
/*!
 * I2C write function map to COINES platform
 */
BME68X_INTF_RET_TYPE bme68x_i2c_write(uint8_t reg_addr, const uint8_t *reg_data, uint32_t len, void *intf_ptr)
{
    uint8_t device_addr = *(uint8_t*)intf_ptr;
 
    (void)intf_ptr;
 
    return coines_write_i2c(COINES_I2C_BUS_0, device_addr, reg_addr, (uint8_t *)reg_data, (uint16_t)len);
}
 
/*!
 * SPI read function map to COINES platform
 */
BME68X_INTF_RET_TYPE bme68x_spi_read(uint8_t reg_addr, uint8_t *reg_data, uint32_t len, void *intf_ptr)
{
    uint8_t device_addr = *(uint8_t*)intf_ptr;
 
    (void)intf_ptr;
 
    return coines_read_spi(COINES_SPI_BUS_0, device_addr, reg_addr, reg_data, (uint16_t)len);
}
 
/*!
 * SPI write function map to COINES platform
 */
BME68X_INTF_RET_TYPE bme68x_spi_write(uint8_t reg_addr, const uint8_t *reg_data, uint32_t len, void *intf_ptr)
{
    uint8_t device_addr = *(uint8_t*)intf_ptr;
 
    (void)intf_ptr;
 
    return coines_write_spi(COINES_SPI_BUS_0, device_addr, reg_addr, (uint8_t *)reg_data, (uint16_t)len);
}
 
/*!
 * Delay function map to COINES platform
 */
void bme68x_delay_us(uint32_t period, void *intf_ptr)
{
    (void)intf_ptr;
    coines_delay_usec(period);
}
 
void bme68x_check_rslt(const char api_name[], int8_t rslt)
{
    switch (rslt)
    {
        case BME68X_OK:
 
            /* Do nothing */
            break;
        case BME68X_E_NULL_PTR:
            printf("API name [%s]  Error [%d] : Null pointer\r\n", api_name, rslt);
            break;
        case BME68X_E_COM_FAIL:
            printf("API name [%s]  Error [%d] : Communication failure\r\n", api_name, rslt);
            break;
        case BME68X_E_INVALID_LENGTH:
            printf("API name [%s]  Error [%d] : Incorrect length parameter\r\n", api_name, rslt);
            break;
        case BME68X_E_DEV_NOT_FOUND:
            printf("API name [%s]  Error [%d] : Device not found\r\n", api_name, rslt);
            break;
        case BME68X_E_SELF_TEST:
            printf("API name [%s]  Error [%d] : Self test error\r\n", api_name, rslt);
            break;
        case BME68X_W_NO_NEW_DATA:
            printf("API name [%s]  Warning [%d] : No new data found\r\n", api_name, rslt);
            break;
        default:
            printf("API name [%s]  Error [%d] : Unknown error code\r\n", api_name, rslt);
            break;
    }
}
 
int8_t bme68x_interface_init(struct bme68x_dev *bme, uint8_t intf)
{
    int8_t rslt = BME68X_OK;
    struct coines_board_info board_info;
 
    if (bme != NULL)
    {
        int16_t result = coines_open_comm_intf(COINES_COMM_INTF_USB, NULL);
        if (result < COINES_SUCCESS)
        {
            printf(
                "\n Unable to connect with Application Board ! \n" " 1. Check if the board is connected and powered on. \n" " 2. Check if Application Board USB driver is installed. \n"
                " 3. Check if board is in use by another application. (Insufficient permissions to access USB) \n");
            exit(result);
        }
 
        result = coines_get_board_info(&board_info);
 
#if defined(PC)
        setbuf(stdout, NULL);
#endif
 
        if (result == COINES_SUCCESS)
        {
            if ((board_info.shuttle_id != BME68X_SHUTTLE_ID))
            {
                printf(
                    "! Warning invalid sensor shuttle : 0x%x (Expected : 0x%x) \n ," "This application will not support this sensor \n",
                    board_info.shuttle_id,
                    BME68X_SHUTTLE_ID);
            }
        }
 
        (void)coines_set_shuttleboard_vdd_vddio_config(0, 0);
        coines_delay_msec(100);
 
        /* Bus configuration : I2C */
        if (intf == BME68X_I2C_INTF)
        {
            printf("I2C Interface\n");
            dev_addr = BME68X_I2C_ADDR_LOW;
            bme->read = bme68x_i2c_read;
            bme->write = bme68x_i2c_write;
            bme->intf = BME68X_I2C_INTF;
 
            /* SDO pin is made low */
            (void)coines_set_pin_config(COINES_SHUTTLE_PIN_SDO, COINES_PIN_DIRECTION_OUT, COINES_PIN_VALUE_LOW);
 
            (void)coines_config_i2c_bus(COINES_I2C_BUS_0, COINES_I2C_STANDARD_MODE);
        }
        /* Bus configuration : SPI */
        else if (intf == BME68X_SPI_INTF)
        {
            printf("SPI Interface\n");
            dev_addr = COINES_SHUTTLE_PIN_7;
            bme->read = bme68x_spi_read;
            bme->write = bme68x_spi_write;
            bme->intf = BME68X_SPI_INTF;
            (void)coines_config_spi_bus(COINES_SPI_BUS_0, COINES_SPI_SPEED_7_5_MHZ, COINES_SPI_MODE0);
        }
 
        coines_delay_msec(100);
 
        (void)coines_set_shuttleboard_vdd_vddio_config(3300, 3300);
 
        coines_delay_msec(100);
 
        bme->delay_us = bme68x_delay_us;
        bme->intf_ptr = &dev_addr;
        bme->amb_temp = 25; /* The ambient temperature in deg C is used for defining the heater temperature */
    }
    else
    {
        rslt = BME68X_E_NULL_PTR;
    }
 
    return rslt;
}
 
void bme68x_coines_deinit(void)
{
    (void)fflush(stdout);
 
    (void)coines_set_shuttleboard_vdd_vddio_config(0, 0);
    coines_delay_msec(1000);
 
    /* Coines interface reset */
    coines_soft_reset();
    coines_delay_msec(1000);
    (void)coines_close_comm_intf(COINES_COMM_INTF_USB, NULL);
}
#else
 
/** \fn BME68X_INTF_RET_TYPE bme68x_i2c_read(uint8_t reg_addr, uint8_t *reg_data, uint32_t len, void *intf_ptr)
 *
 *  @brief Function for reading the sensor's registers through I2C bus.
 *
 *  @param[in] reg_addr     : Register address.
 *  @param[out] reg_data    : Pointer to the data buffer to store the read data.
 *  @param[in] len          : No of bytes to read.
 *  @param[in] intf_ptr     : Interface pointer
 *
 *  @return Status of execution
 *  @retval = BME68X_INTF_RET_SUCCESS -> Success
 *  @retval != BME68X_INTF_RET_SUCCESS  -> Failure Info
 */
BME68X_INTF_RET_TYPE bme68x_i2c_read(uint8_t reg_addr, uint8_t *reg_data, uint32_t len, void *intf_ptr) {
  uint8_t device_addr = *(uint8_t *)intf_ptr;
 
  (void)intf_ptr;
  return i2c_read(i2c_dev, reg_data, len, device_addr);
  //    return coines_read_i2c(COINES_I2C_BUS_0, device_addr, reg_addr, reg_data, (uint16_t)len);
}
 
/** \fn BME68X_INTF_RET_TYPE bme68x_i2c_write(uint8_t reg_addr, const uint8_t *reg_data, uint32_t len, void *intf_ptr)
 *
 *  @brief Function for writing the sensor's registers through I2C bus.
 *
 *  @param[in] reg_addr     : Register address.
 *  @param[in] reg_data     : Pointer to the data buffer whose value is to be written.
 *  @param[in] len          : No of bytes to write.
 *  @param[in] intf_ptr     : Interface pointer
 *
 *  @return Status of execution
 *  @retval = BME68X_INTF_RET_SUCCESS -> Success
 *  @retval != BME68X_INTF_RET_SUCCESS  -> Failure Info
 *
 */
BME68X_INTF_RET_TYPE bme68x_i2c_write(uint8_t reg_addr, const uint8_t *reg_data, uint32_t len, void *intf_ptr) {
  uint8_t device_addr = *(uint8_t *)intf_ptr;
 
  (void)intf_ptr;
  return i2c_write(i2c_dev, reg_data, len, device_addr);
  //  return coines_write_i2c(COINES_I2C_BUS_0, device_addr, reg_addr, (uint8_t *)reg_data, (uint16_t)len);
}
 
/** \fn BME68X_INTF_RET_TYPE bme68x_spi_read(uint8_t reg_addr, uint8_t *reg_data, uint32_t len, void *intf_ptr)
 *
 *  @brief Function for reading the sensor's registers through SPI bus.
 *
 *  @param[in] reg_addr     : Register address.
 *  @param[out] reg_data    : Pointer to the data buffer to store the read data.
 *  @param[in] len          : No of bytes to read.
 *  @param[in] intf_ptr     : Interface pointer
 *
 *  @return Status of execution
 *  @retval = BME68X_INTF_RET_SUCCESS -> Success
 *  @retval != BME68X_INTF_RET_SUCCESS  -> Failure Info
 */
BME68X_INTF_RET_TYPE bme68x_spi_read(uint8_t reg_addr, uint8_t *reg_data, uint32_t len, void *intf_ptr) {
  //    uint8_t device_addr = *(uint8_t *)intf_ptr;
  uint8_t i = 0;
  int ret;
 
  /* zero buffer and load the command */
  for (i = 0; i < len; i++)
    buffer_tx[i] = 0;
  buffer_tx[0] = reg_addr;
  tx_bufs[0].len = len + 1;
  rx_bufs[0].len = len + 1;
 
  /* enable CS and send command  */
  ret = spi_transceive(spi_dev, &spi_cfg2, &tx, &rx);
 
  /* shift bytes back to caller byte 0 is not valid data */
  for (i = 0; i < len; i++) {
    reg_data[i] = buffer_rx[i + 1];
  }
 
  //    myPrintkS("bme68x_spi_read reg_addr: 0x%02X reg_data: 0x%02X len: %d dev_addr: %d\r\n", reg_addr, reg_data[0], len, device_addr);
  //    if (len > 1)
  //    {
  //        for (int i = 0; i < len; i++)
  //        {
  //            myPrintkS("i: %d 0x%02X\r\n", i, reg_data[i]);
  //        }
  //    }
  return ret;
#if 0
    return coines_read_spi(COINES_SPI_BUS_0, device_addr, reg_addr, reg_data, (uint16_t)len);
#endif
}
 
/** \fn BME68X_INTF_RET_TYPE bme68x_spi_write(uint8_t reg_addr, const uint8_t *reg_data, uint32_t len, void *intf_ptr)
 *
 *  @brief Function for writing the sensor's registers through SPI bus.
 *
 *  @param[in] reg_addr     : Register address.
 *  @param[in] reg_data     : Pointer to the data buffer whose data has to be written.
 *  @param[in] len          : No of bytes to write.
 *  @param[in] intf_ptr     : Interface pointer
 *
 *  @return Status of execution
 *  @retval = BME68X_INTF_RET_SUCCESS -> Success
 *  @retval != BME68X_INTF_RET_SUCCESS  -> Failure Info
 */
BME68X_INTF_RET_TYPE bme68x_spi_write(uint8_t reg_addr, const uint8_t *reg_data, uint32_t len, void *intf_ptr) {
  //    uint8_t device_addr = *(uint8_t *)intf_ptr;
  uint8_t i = 0;
 
  (void)intf_ptr;
 
  buffer_tx[0] = reg_addr & BME68X_SPI_WR_MSK;
  for (i = 0; i < len; i++) {
    buffer_tx[i + 1] = reg_data[i];
  }
  tx_bufs[0].len = len + 1;
  rx_bufs[0].len = len + 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg2, &tx, &rx);
  return ret;
#if 0
    return coines_write_spi(COINES_SPI_BUS_0, device_addr, reg_addr, (uint8_t *)reg_data, (uint16_t)len);
#endif
}
 
/** \fn void bme68x_delay_us(uint32_t period, void *intf_ptr)
 * @brief This function provides the delay for required time (Microsecond) as per the input provided in some of the
 * APIs.
 *
 *  @param[in] period       : The required wait time in microsecond.
 *  @param[in] intf_ptr     : Interface pointer
 *
 */
void bme68x_delay_us(uint32_t period, void *intf_ptr) {
  (void)intf_ptr;
  // Use Zephyr kernel sleep for a microsecond delay.
  //    coines_delay_usec(period);
  k_sleep(K_USEC(period));
}
 
/** \fn void bme68x_check_rslt(const char api_name[], int8_t rslt)
 *
 *  \brief Log BME68X API result and error details.
 *
 *  \param api_name Name of the called BME68X API.
 *  \param rslt Result code returned by the BME68X function.
 */
void bme68x_check_rslt(const char api_name[], int8_t rslt) {
  switch (rslt) {
  case BME68X_OK:
    myPrintkS("BME688 API name [%s]  OK\r\n", api_name, rslt);
    /* Do nothing */
    break;
  case BME68X_E_NULL_PTR:
    myPrintkS("BME688 API name [%s]  Error [%d] : Null pointer\r\n", api_name, rslt);
    break;
  case BME68X_E_COM_FAIL:
    myPrintkS("BME688 API name [%s]  Error [%d] : Communication failure\r\n", api_name, rslt);
    break;
  case BME68X_E_INVALID_LENGTH:
    myPrintkS("BME688 API name [%s]  Error [%d] : Incorrect length parameter\r\n", api_name, rslt);
    break;
  case BME68X_E_DEV_NOT_FOUND:
    myPrintkS("BME688 API name [%s]  Error [%d] : Device not found\r\n", api_name, rslt);
    break;
  case BME68X_E_SELF_TEST:
    myPrintkS("BME688 API name [%s]  Error [%d] : Self test error\r\n", api_name, rslt);
    break;
  case BME68X_W_NO_NEW_DATA:
    myPrintkS("BME688 API name [%s]  Warning [%d] : No new data found\r\n", api_name, rslt);
    break;
  default:
    myPrintkS("BME688 API name [%s]  Error [%d] : Unknown error code\r\n", api_name, rslt);
    break;
  }
}
 
/*!
 *  @brief Function to select the interface between SPI and I2C.
 *
 *  @param[in] bme      : Structure instance of bme68x_dev
 *  @param[in] intf     : Interface selection parameter
 *
 *  @return Status of execution
 *  @retval 0 -> Success
 *  @retval < 0 -> Failure Info
 */
int8_t bme68x_interface_init(struct bme68x_dev *bme, uint8_t intf) {
  int8_t rslt = BME68X_OK;
  //    struct coines_board_info board_info;
 
  if (bme != NULL) {
    //        int16_t result = coines_open_comm_intf(COINES_COMM_INTF_USB, NULL);
    //        if (result < COINES_SUCCESS)
    //        {
    //            printf(
    //                "\n Unable to connect with Application Board ! \n"
    //                " 1. Check if the board is connected and powered on. \n"
    //                " 2. Check if Application Board USB driver is installed. \n"
    //                " 3. Check if board is in use by another application. (Insufficient permissions to access USB) \n");
    //            exit(result);
    //        }
    //
    //        result = coines_get_board_info(&board_info);
    //
    // #if defined(PC)
    //        setbuf(stdout, NULL);
    // #endif
    //
    //        if (result == COINES_SUCCESS)
    //        {
    //            if ((board_info.shuttle_id != BME68X_SHUTTLE_ID))
    //            {
    //                printf(
    //                    "! Warning invalid sensor shuttle : 0x%x (Expected : 0x%x) \n ,"
    //                    "This application will not support this sensor \n",
    //                    board_info.shuttle_id,
    //                    BME68X_SHUTTLE_ID);
    //            }
    //        }
    //
    //        (void)coines_set_shuttleboard_vdd_vddio_config(0, 0);
    //        coines_delay_msec(100);
 
    /* Bus configuration : I2C */
    if (intf == BME68X_I2C_INTF) {
      myPrintkS("I2C Interface\n");
      dev_addr = BME68X_I2C_ADDR_LOW;
      bme->read = bme68x_i2c_read;
      bme->write = bme68x_i2c_write;
      bme->intf = BME68X_I2C_INTF;
 
      //            /* SDO pin is made low */
      //            (void)coines_set_pin_config(COINES_SHUTTLE_PIN_SDO, COINES_PIN_DIRECTION_OUT, COINES_PIN_VALUE_LOW);
      //
      //            (void)coines_config_i2c_bus(COINES_I2C_BUS_0, COINES_I2C_STANDARD_MODE);
    }
    /* Bus configuration : SPI */
    else if (intf == BME68X_SPI_INTF) {
      myPrintkS("SPI Interface %d\n", spics2n.pin);
      //            dev_addr = COINES_SHUTTLE_PIN_7;
      dev_addr = spics2n.pin;
      bme->read = bme68x_spi_read;
      bme->write = bme68x_spi_write;
      bme->intf = BME68X_SPI_INTF;
      //            (void)coines_config_spi_bus(COINES_SPI_BUS_0, COINES_SPI_SPEED_7_5_MHZ, COINES_SPI_MODE0);
    }
 
    //        coines_delay_msec(100);
    k_sleep(K_MSEC(100));
    //
    //        (void)coines_set_shuttleboard_vdd_vddio_config(3300, 3300);
    //
    //        coines_delay_msec(100);
 
    bme->delay_us = bme68x_delay_us;
    bme->intf_ptr = &dev_addr;
    bme->amb_temp = 25; /* The ambient temperature in deg C is used for defining the heater temperature */
  } else {
    rslt = BME68X_E_NULL_PTR;
  }
 
  return rslt;
}
#endif