/* I2C Configuration */
#define BOARD_I2C_SCL \
  (GPIO_INPUT | GPIO_PULLUP | GPIO_FUNC_I2C | \
  GPIO_PIN2)
#define BOARD_I2C_SDA \
  (GPIO_INPUT | GPIO_PULLUP | GPIO_FUNC_I2C | \
  GPIO_PIN1)

config ESP32_I2C0_SCLPIN
  int "I2C0 SCL Pin"
  default 22
  range 0 39

config ESP32_I2C0_SDAPIN
  int "I2C0 SDA Pin"
  default 23
  range 0 39

//  Previously: I2C Address of BMP280
//  #define BMP280_ADDR     0x76

//  Testing: I2C Address of BME280
#define BMP280_ADDR         0x77

//  Previously: Device ID of BMP280
//  #define DEVID           0x58

//  Testing: Device ID of BME280
#define DEVID               0x60

#ifdef CONFIG_SENSORS_BMP280
#include <nuttx/sensors/bmp280.h>
#endif  //  CONFIG_SENSORS_BMP280
...
int bl602_bringup(void) {
...
#ifdef CONFIG_SENSORS_BMP280
  //  Init I2C bus for BMP280
  struct i2c_master_s *bmp280_i2c_bus = 
    bl602_i2cbus_initialize(0);
  if (!bmp280_i2c_bus) {
    _err("ERROR: Failed to get I2C%d interface\n", 0);
  }

  //  Register the BMP280 driver
  ret = bmp280_register(0, bmp280_i2c_bus);
  if (ret < 0) {
    _err("ERROR: Failed to register BMP280\n");
  }
#endif  //  CONFIG_SENSORS_BMP280

bl602_i2c_transfer: i2c transfer success
bmp280_checkid:  devid: 0x00
bmp280_checkid:  Wrong Device ID! 00
bmp280_register: Failed to register driver: -19
bl602_bringup:   ERROR: Failed to register BMP280

Write  [0xEE]
0x00 + ACK (Register ID is 0x00, which is incorrect!)
Read   [0xEF]
0x00 + NAK (Invalid result, because Register ID is incorrect!)

static int bl602_i2c_transfer(struct i2c_master_s *dev, struct i2c_msg_s *msgs, int count) {
  ...
  //  if msgs[i].flag I2C_M_NOSTOP,means start i2c with subddr
  if (msgs[i].flags & I2C_M_NOSTOP) {
    priv->subflag = 1;
    priv->subaddr = 0;
    for (j = 0; j < msgs[i].length; j++) {
      priv->subaddr += msgs[i].buffer[j] << (j * 8);
    }
    priv->sublen = msgs[i].length;
    i++;

//  Read a single BME280 Register
static uint8_t bmp280_getreg8(FAR struct bmp280_dev_s *priv, uint8_t regaddr) {
  ...
  msg[0].frequency = priv->freq;
  msg[0].addr      = priv->addr;

#ifdef CONFIG_BL602_I2C0
  //  For BL602: Register ID must be passed as I2C Sub Address
  msg[0].flags     = I2C_M_NOSTOP;
#else
  //  Otherwise pass Register ID as I2C Data
  msg[0].flags     = 0;
#endif  //  CONFIG_BL602_I2C0

  msg[0].buffer    = &regaddr;
  msg[0].length    = 1;

sensor_custom_register: Registering /dev/uorb/sensor_baro0
bmp280_register: BMP280 driver loaded successfully!
NuttShell (NSH) NuttX-10.2.0-RC0

nsh> ls /dev/uorb
/dev/uorb:
 sensor_baro0

nsh> sensortest -n 10 baro0
SensorTest: Test /dev/uorb/sensor_baro0 with interval(1000000us), latency(0us)
baro0: timestamp:30680000 value1:674.93 value2:22.18
baro0: timestamp:30680000 value1:674.93 value2:22.18
baro0: timestamp:30680000 value1:674.93 value2:22.18
baro0: timestamp:30680000 value1:674.93 value2:22.18
baro0: timestamp:30680000 value1:674.93 value2:22.18
baro0: timestamp:30690000 value1:674.93 value2:22.18
baro0: timestamp:30690000 value1:674.93 value2:22.18
baro0: timestamp:30690000 value1:674.93 value2:22.18
baro0: timestamp:30690000 value1:1006.21 value2:30.78
baro0: timestamp:30690000 value1:1006.21 value2:30.78
SensorTest: Received message: baro0, number:10/10

//  Fetch pressure, temperature and humidity from sensor
static int bme280_fetch(
  FAR struct device *priv,  //  NuttX Device Struct
  FAR struct sensor_baro *baro_data,  //  Returns pressure and temperature (if non-null)
  FAR struct sensor_humi *humi_data   //  Returns humidity (if non-null)
) {

  //  Zephyr BME280 Driver assumes that sensor is not in sleep mode
  if (!priv->activated) {
    snerr("Device must be active before fetch\n");
    return -EIO;
  }

  //  Fetch the sensor sample (from Zephyr BME280 Driver)
  int ret = bme280_sample_fetch(
    priv,            //  NuttX Device Struct
    SENSOR_CHAN_ALL  //  Fetch Temperature, Humidity and Pressure
  );
  if (ret < 0) { return ret; }

  //  Get the pressure (from Zephyr BME280 Driver)
  struct sensor_value val;
  ret = bme280_channel_get(
    priv,               //  NuttX Device Struct
    SENSOR_CHAN_PRESS,  //  Get Pressure from fetched sample
    &val                //  Pressure in Fixed Point format
  );
  if (ret < 0) { return ret; }

  //  Convert pressure to float, scale up by 10 to convert kilopascal to millibars
  float pressure = get_sensor_value(&val) * 10;

  //  Get the temperature (from Zephyr BME280 Driver)
  ret = bme280_channel_get(
    priv,                      //  NuttX Device Struct
    SENSOR_CHAN_AMBIENT_TEMP,  //  Get Temperature from fetched sample
    &val                       //  Temperature in Fixed Point format
  );
  if (ret < 0) { return ret; }
  float temperature = get_sensor_value(&val);

  //  Get the humidity (from Zephyr BME280 Driver)
  ret = bme280_channel_get(
    priv,                  //  NuttX Device Struct
    SENSOR_CHAN_HUMIDITY,  //  Get Humidity from fetched sample
    &val                   //  Humidity in Fixed Point format
  );
  if (ret < 0) { return ret; }
  float humidity = get_sensor_value(&val);

  //  Get the timestamp  
  struct timespec ts;
  clock_systime_timespec(&ts);
  uint64_t timestamp = 1000000ull * ts.tv_sec + ts.tv_nsec / 1000;

  //  Return the pressure and temperature data
  if (baro_data != NULL) {
    baro_data->pressure    = pressure;
    baro_data->temperature = temperature;
    baro_data->timestamp   = timestamp;
  }

  //  Return the humidity data
  if (humi_data != NULL) {
    humi_data->humidity    = humidity;
    humi_data->timestamp   = timestamp;
  }
  return 0;
}

//  If enable is true, set Power Mode to normal. Else set to sleep mode.
static int bme280_activate(
    FAR struct device *priv,  //  NuttX Device Struct
    bool enable               //  True for Normal Mode, False for Sleep Mode
) {
  int ret = 0;
  if (enable) {
    //  Set power mode to normal (from Zephyr BME280 Driver)
    ret = bme280_pm_action(
      priv,                     //  NuttX Device Struct
      PM_DEVICE_ACTION_RESUME   //  Resume from Sleep Mode
    );
  } else {
    //  Set to sleep mode (from Zephyr BME280 Driver)
    ret = bme280_pm_action(
      priv,                     //  NuttX Device Struct
      PM_DEVICE_ACTION_SUSPEND  //  Suspend to Sleep Mode
    );
  }
  //  Remember the power mode
  if (ret >= 0) { priv->activated = enable; }
  return ret;
}

//  Set Standby Interval for the sensor
static int bme280_set_interval(
  FAR struct device *priv,     //  NuttX Device Struct
  FAR unsigned int *period_us  //  Standby Interval in microseconds
) {
  //  Convert the Standby Interval to BME280 constant
  int ret = 0;
  uint8_t regval;
  switch (*period_us) {
    case 500: 
      regval = BME280_STANDBY_05_MS; break;
    ...
    case 4000000:
      regval = BME280_STANDBY_4000_MS; break;
    default:
      ret = -EINVAL; break;
  }

  //  Set the Standby Interval
  if (ret == 0) {
    ret = bme280_set_standby(priv, regval);
  }
  return ret;
}

//  Set Standby Duration. Zephyr assumes that Standby Duration is static, so we set it in NuttX.
static int bme280_set_standby(
  FAR struct device *priv,  //  NuttX Device Struct
  uint8_t value             //  BME280 constant for Standby Duration
) {
  //  Set the standby duration value by writing to BME280 Register
  int ret = bme280_reg_read(priv, BME280_REG_CONFIG, &v_data_u8, 1);
  uint8_t v_data_u8 = (v_data_u8 & ~(0x07 << 5)) | (value << 5);
  ret = bme280_reg_write(priv, BME280_REG_CONFIG, v_data_u8);
  ...
  //  Check the standby duration value by reading from BME280 Register
  ret = bme280_reg_read(priv, BME280_REG_CONFIG, &v_data_u8, 1);
  uint8_t v_sb_u8 = (v_data_u8 >> 5) & 0x07;
  //  Omitted: Return error if v_sb_u8 != value

//  NuttX Device for BME280
struct device {
  //  Barometer Sensor (Pressure + Temperature)
  FAR struct sensor_lowerhalf_s sensor_baro;  
  //  Humidity Sensor
  FAR struct sensor_lowerhalf_s sensor_humi;  

  FAR struct i2c_master_s *i2c;  //  NuttX I2C interface
  uint8_t addr;                  //  BME280 I2C address
  int     freq;                  //  BME280 Frequency <= 3.4MHz
  bool    activated;             //  True if device is not in sleep mode
  char    *name;                 //  Name of the device (BME280)
  struct  bme280_data *data;     //  Compensation parameters (bme280.c)
};

//  Operations for Barometer Sensor
static const struct sensor_ops_s g_baro_ops = {
  .activate      = bme280_activate_baro,
  .fetch         = bme280_fetch_baro,
  .set_interval  = bme280_set_interval_baro,
};

//  Operations for Humidity Sensor
static const struct sensor_ops_s g_humi_ops = {
  .activate      = bme280_activate_humi,
  .fetch         = bme280_fetch_humi,
  .set_interval  = bme280_set_interval_humi,
};

//  Called by NuttX to fetch pressure and temperature from sensor
static int bme280_fetch_baro(
  FAR struct sensor_lowerhalf_s *lower,  //  Barometer Sensor
  FAR struct file *filep,  // NuttX File
  FAR char *buffer,  //  Buffer to return Sensor Data
  size_t buflen      //  Size of Buffer
) {
  //  Get NuttX Device Struct
  FAR struct device *priv = container_of(
    lower,              //  Barometer Sensor
    FAR struct device,  //  NuttX Device Struct
    sensor_baro         //  Barometer Sensor Struct
  );

  //  Validate buffer size
  struct sensor_baro baro_data;
  if (buflen != sizeof(baro_data)) { return -EINVAL; }

  //  Fetch the sensor data
  int ret = bme280_fetch(priv, &baro_data, NULL);
  if (ret < 0) { return ret; }

  //  Return the sensor data
  memcpy(buffer, &baro_data, sizeof(baro_data));
  return buflen;
}

//  Called by NuttX to fetch humidity from sensor
static int bme280_fetch_humi(
  FAR struct sensor_lowerhalf_s *lower,  //  Humidity Sensor
  FAR struct file *filep,  // NuttX File
  FAR char *buffer,  //  Buffer to return Sensor Data
  size_t buflen      //  Size of Buffer
) {
  //  Get NuttX Device Struct
  FAR struct device *priv = container_of(
    lower,              //  Humidity Sensor
    FAR struct device,  //  NuttX Device Struct
    sensor_humi         //  Humidity Sensor Struct
  );

  //  Validate buffer size
  struct sensor_humi humi_data;
  if (buflen != sizeof(humi_data)) { return -EINVAL; }

  //  Fetch the sensor data
  int ret = bme280_fetch(priv, NULL, &humi_data);
  if (ret < 0) { return ret; }

  //  Return the sensor data
  memcpy(buffer, &humi_data, sizeof(humi_data));
  return buflen;
}

//  Register the BME280 device at startup
int bme280_register(
  int devno,  //  Instance number for driver
  FAR struct i2c_master_s *i2c  //  I2C Interface
) {
  //  Initialize the NuttX Device Struct
  FAR struct device *priv = (FAR struct device *)kmm_zalloc(sizeof(struct device));
  ...
  //  Allocate the Compensation Parameters
  struct bme280_data *data = (FAR struct bme280_data *)kmm_zalloc(sizeof(struct bme280_data));
  priv->data = data;
  ...
  //  Initialize the Barometer Sensor
  priv->sensor_baro.ops  = &g_baro_ops;
  priv->sensor_baro.type = SENSOR_TYPE_BAROMETER;

  //  Initialize the Humidity Sensor
  priv->sensor_humi.ops  = &g_humi_ops;
  priv->sensor_humi.type = SENSOR_TYPE_RELATIVE_HUMIDITY;

  //  Initialize the Sensor Hardware (Zephyr BME280 Driver)
  int ret = bme280_chip_init(priv);
  ...
  //  Set Power Mode to sleep (Zephyr BME280 Driver)
  ret = bme280_pm_action(priv, PM_DEVICE_ACTION_SUSPEND);
  ...
  //  Register the Barometer Sensor
  ret = sensor_register(&priv->sensor_baro, devno);
  ...
  //  Register the Humidity Sensor
  ret = sensor_register(&priv->sensor_humi, devno);

#ifdef CONFIG_SENSORS_BME280
#include <nuttx/sensors/bme280.h>
#endif /* CONFIG_SENSORS_BME280 */
...
int bl602_bringup(void) {
  ...
#ifdef CONFIG_SENSORS_BME280
  //  Init I2C bus for BME280
  struct i2c_master_s *bme280_i2c_bus = bl602_i2cbus_initialize(0);
  if (!bme280_i2c_bus) { _err("ERROR: Failed to get I2C%d interface\n", 0); }

  //  Register the BME280 driver
  ret = bme280_register(0, bme280_i2c_bus);
  if (ret < 0) { _err("ERROR: Failed to register BME280\n"); }
#endif  //  CONFIG_SENSORS_BME280

## Go to the NuttX Sensors Source directory
pushd nuttx/nuttx/drivers/sensors

## Add the BME280 Driver as a submodule
git submodule add \
  https://github.com/lupyuen/bme280-nuttx \
  bme280

## Create the Symbolic Link to the bundled source file
ln -s \
  bme280/bundle.c \
  bme280.c

## Return to the top directory
popd

## Go to the NuttX Sensors Include directory
pushd nuttx/nuttx/include/nuttx/sensors

## Create the Symbolic Link to the bundled include file
ln -s \
  ../../../drivers/sensors/bme280/bundle.h \
  bme280.h

## Return to the top directory
popd

//  Zephyr BME280 Options from
//  https://github.com/zephyrproject-rtos/zephyr/blob/main/drivers/sensor/bme280/Kconfig
#define CONFIG_BME280_MODE_NORMAL        //  Normal Sampling Mode (continuous measurements)
#define CONFIG_BME280_TEMP_OVER_2X       //  Temperature Oversamling 2x
#define CONFIG_BME280_PRESS_OVER_16X     //  Pressure Oversampling 16x
#define CONFIG_BME280_HUMIDITY_OVER_16X  //  Humidity Oversampling 16x
#define CONFIG_BME280_STANDBY_1000MS     //  Standby Time 1000ms. Note: Will be overwritten in bme280_set_standby
#define CONFIG_BME280_FILTER_4           //  Filter Coefficient 4
#define CONFIG_PM_DEVICE                 //  Enable Power Management

//  Other Zephyr Defines
#define BME280_BUS_I2C  0  //  I2C Bus
#define BME280_BUS_SPI  0  //  SPI Bus
#define __ASSERT_NO_MSG DEBUGASSERT  //  Assertion check
#define LOG_DBG         sninfo       //  Log info message
#define K_MSEC(ms)      (ms * 1000)  //  Convert milliseconds to microseconds
#define k_sleep(us)     usleep(us)   //  Sleep for microseconds
#define sys_le16_to_cpu(x) (x)       //  Convert from little endian to host endian. TODO: Handle big endian

//  Zephyr Sensor Channel to be fetched from the sensor
enum sensor_channel {
  SENSOR_CHAN_ALL,           //  All Channels
  SENSOR_CHAN_AMBIENT_TEMP,  //  Ambient Temperature
  SENSOR_CHAN_PRESS,         //  Pressure
  SENSOR_CHAN_HUMIDITY,      //  Humidity
};

//  Zephyr Power Management Action
enum pm_device_action {
  PM_DEVICE_ACTION_SUSPEND,  //  Suspend the sensor
  PM_DEVICE_ACTION_RESUME,   //  Resume the sensor
};

//  Zephyr Power Management State
enum pm_device_state {
  PM_DEVICE_STATE_ACTIVE,     //  Sensor is active
  PM_DEVICE_STATE_SUSPENDED,  //  Sensor is suspended
};
 
//  Zephyr Sensor Value
struct sensor_value {
  int32_t val1;  //  Integer part of the value
  int32_t val2;  //  Fractional part of the value (in one-millionth parts)
};

//  Embed Zephyr BME280 Driver
#include "bme280/bme280.c"

//  Embed NuttX Driver Wrapper
#include "bme280/driver.c"

nsh> sensortest -n 1 baro0
baro0: 
  timestamp: 43760000 
  value1:     1011.29 
  value2:       29.09

nsh> sensortest -n 1 humi0
humi0: 
  timestamp: 60120000 
  value:     90.58

//  Sensor Test App
int main(int argc, FAR char *argv[]) {
  ...
  //  Allocate buffer for Sensor Data.
  //  len is Sensor Data size: sizeof(struct sensor_baro)
  FAR char *buffer = calloc(1, len);

  //  Open the Sensor Device.
  //  devname looks like "/dev/uorb/sensor_baro0"
  int fd = open(devname, O_RDONLY | O_NONBLOCK);
  if (fd < 0) { /* Handle error */ ... }

  //  Set Standby Interval
  int ret = ioctl(fd, SNIOC_SET_INTERVAL, interval);
  if (ret < 0) { /* Handle error */ ... }

  //  Set Batch Latency
  ret = ioctl(fd, SNIOC_BATCH, latency);
  if (ret < 0) { /* Handle error */ ... }

  //  Prepare to poll the Sensor
  struct pollfd fds;
  fds.fd     = fd;
  fds.events = POLLIN;

  //  Repeat until all samples have been read
  while ((!count || received < count) && !g_should_exit) {

    //  If Sensor Data is available...
    if (poll(&fds, 1, -1) > 0) {

      //  Read the Sensor Data
      if (read(fd, buffer, len) >= len) {

        //  Print the Sensor Data
        received++;
        g_sensor_info[idx]
          .print(buffer, name);
      }
    }
  }

  //  Close the Sensor Device and free the buffer
  close(fd);
  free(buffer);

//  Print the Sensor Data
g_sensor_info[idx]
  .print(buffer, name);

//  Print Barometer Sensor Data: Pressure and Temperature
static void print_valf2(const char *buffer, const char *name) {

  //  Cast buffer as Barometer Sensor Data
  struct sensor_baro *event = 
    (struct sensor_baro *) buffer;

  //  Print Pressure and Temperature
  printf(
    "%s: timestamp:%" PRIu64 " value1:%.2f value2:%.2f\n",
    name, 
    event->timestamp, 
    event->pressure, 
    event->temperature
  );
}

//  Print Humidity or Proximity Sensor Data
static void print_valf(const char *buffer, const char *name) {

  //  Cast buffer as Proximity Sensor Data,
  //  which has same size as Humidity Sensor Data
  struct sensor_prox *event = 
    (struct sensor_prox *) buffer;

  //  Print Humidity or Proximity
  printf(
    "%s: timestamp:%" PRIu64 " value:%.2f\n",
    name, 
    event->timestamp, 
    event->proximity
  );
}

//  Cast buffer as Humidity Sensor Data
struct sensor_humi *event = 
  (struct sensor_humi *) buffer;

//  Lookup Table of all Sensor Types
static const struct sensor_info g_sensor_info[] = {
  ...
  //  Print Barometer Sensor Data with print_valf2
  { print_valf2, 
    sizeof(struct sensor_baro), 
    "baro" },

  //  Print Humidity Sensor Data with print_valf
  { print_valf,  
    sizeof(struct sensor_humi), 
    "humi" },

//  Read from 8-bit BME280 registers
static int bme280_reg_read(const struct device *priv,
  uint8_t start, uint8_t *buf, int size) {
  struct i2c_msg_s msg[2];
  int ret;

  //  Send Register ID
  msg[0].frequency = priv->freq;
  msg[0].addr      = priv->addr;
#ifdef CONFIG_BL602_I2C0
  //  For BL602: Register ID must be passed as I2C Sub Address
  msg[0].flags     = I2C_M_NOSTOP;
#else
  //  Otherwise pass Register ID as I2C Data
  msg[0].flags     = 0;
#endif  //  CONFIG_BL602_I2C0
  msg[0].buffer    = &start;
  msg[0].length    = 1;

  //  Receive Register Value
  msg[1].frequency = priv->freq;
  msg[1].addr      = priv->addr;
  msg[1].flags     = I2C_M_READ;
  msg[1].buffer    = buf;
  msg[1].length    = size;

  //  Execute I2C transfers
  ret = I2C_TRANSFER(priv->i2c, msg, 2);

//  Write to an 8-bit BME280 register
static int bme280_reg_write(const struct device *priv, uint8_t reg,
  uint8_t val) {
  struct i2c_msg_s msg[2];
  uint8_t txbuffer[2];
  uint8_t rxbuffer[1];
  int ret;

  //  Transmit buffer contains Register ID and value
  txbuffer[0] = reg;
  txbuffer[1] = val;

  //  Send Register ID and value
  msg[0].frequency = priv->freq;
  msg[0].addr      = priv->addr;
#ifdef CONFIG_BL602_I2C0
  //  For BL602: Register ID and value must be passed as I2C Sub Address
  msg[0].flags     = I2C_M_NOSTOP;
#else
  //  Otherwise pass Register ID and value as I2C Data
  msg[0].flags     = 0;
#endif  //  CONFIG_BL602_I2C0
  msg[0].buffer    = txbuffer;
  msg[0].length    = 2;

  //  For BL602: We read I2C Data because this 
  //  forces BL602 to send the first message correctly
  msg[1].frequency = priv->freq;
  msg[1].addr      = priv->addr;
  msg[1].flags     = I2C_M_READ;
  msg[1].buffer    = rxbuffer;
  msg[1].length    = sizeof(rxbuffer);

  //  Execute I2C transfers
  ret = I2C_TRANSFER(priv->i2c, msg, 2);

Setup Write to [0xEE] + ACK
0xF5 + ACK
0xA0 + ACK
Setup Read to [0xEF] + ACK
0xA0 + NAK

Setup Write to [0x02] + NAK

Setup Write to [0xEE] + ACK
0x00 + ACK
0x00 + ACK
(...600 microseconds later...)
Setup Read to [0xEF] + ACK
0x00 + NAK

//  Define I2C message and buffer
static i2c_msg_t read_msg;    //  Message for reading I2C Data
static uint8_t read_buf[32];  //  Buffer for reading I2C Data

static void test_i2c_start_read(char *buf, int len, int argc, char **argv) {
  //  Start reading data from I2C device
  //  Expect result 0x60 for BME280, 0x58 for BMP280
  int data_len = 1;  //  Bytes to be read
  memset(read_buf, 0, sizeof(read_buf));

  //  Set the I2C operation    
  read_msg.i2cx    = 0;            //  I2C Port
  read_msg.direct  = I2C_M_READ;   //  Read I2C data
  read_msg.block   = I2C_M_BLOCK;  //  Wait until data has been read

  //  Set the I2C buffer
  read_msg.buf     = read_buf;     //  Read buffer
  read_msg.len     = data_len;     //  Number of bytes to be read
  read_msg.idex    = 0;            //  Index of next byte to be read into buf

  //  Set device address and register address
  read_msg.addr    = 0x77;   //  BME280 I2C Secondary Address (Primary Address is 0x76)
  read_msg.subflag = 1;      //  Enable Register Address
  read_msg.subaddr = 0xd0;   //  Register Address (BME280 Chip ID)
  read_msg.sublen  = 1;      //  Length of Register Address (bytes)

  //  Start the I2C transfer and enable I2C interrupts
  gpstmsg = &read_msg;
  i2c_transfer_start(&read_msg);

//  Execute the I2C transfers
static int bl602_i2c_transfer(struct i2c_master_s *dev, struct i2c_msg_s *msgs, int count) {
  ...
  priv->msgv = msgs;

  //  Execute each I2C Transfer...
  for (i = 0; i < count; i++)
    {
      priv->bytes    = 0;
      priv->i2cstate = EV_I2C_END_INT;

      bl602_i2c_set_freq(msgs[i].frequency);

      //  If I2C_M_NOSTOP is specified, 
      //  send entire message as I2C Sub Address
      if (msgs[i].flags & I2C_M_NOSTOP)
        {
          priv->subflag = 1;
          priv->subaddr = 0;
          for (j = 0; j < msgs[i].length; j++)
            {
              priv->subaddr += msgs[i].buffer[j] << (j * 8);
            }

          //  Note: Entire message is the I2C Sub Address!
          priv->sublen = msgs[i].length;
          i++;
        }
      //  Else send message as I2C Data
      //  (Read / Write Transfer)
      else
        {
          priv->subflag = 0;
          priv->subaddr = 0;
          priv->sublen  = 0;
        }

      priv->msgid = i;
      bl602_i2c_start_transfer(priv);

//  Configure the parameters for an I2C Transfer
static void bl602_i2c_config_para(struct bl602_i2c_priv_s *priv) {
  struct i2c_msg_s *msg = &priv->msgv[priv->msgid];

  //  Set the I2C Direction: Read or write
  if (msg->flags & I2C_M_READ)
    {
      modifyreg32(BL602_I2C_CONFIG, 0, I2C_CONFIG_CR_I2C_PKT_DIR);
    }
  else
    {
      modifyreg32(BL602_I2C_CONFIG, I2C_CONFIG_CR_I2C_PKT_DIR, 0);
    }

  //  Set the I2C Address
  modifyreg32(BL602_I2C_CONFIG,
              I2C_CONFIG_CR_I2C_SLV_ADDR_MASK,
              msg->addr << I2C_CONFIG_CR_I2C_SLV_ADDR_SHIFT);

  //  If this I2C Transfer is for I2C Sub Address...
  if (priv->subflag > 0)
    {
      //  Enable I2C Sub Address
      modifyreg32(BL602_I2C_CONFIG, 0, I2C_CONFIG_CR_I2C_SUB_ADDR_EN);
      //  Set the I2C Sub Address length
      modifyreg32(BL602_I2C_CONFIG,
                  I2C_CONFIG_CR_I2C_SUB_ADDR_BC_MASK,
                  (priv->sublen - 1) << I2C_CONFIG_CR_I2C_SUB_ADDR_BC_SHIFT);
    }
  else
    {
      //  Else disable I2C Sub Address
      modifyreg32(BL602_I2C_CONFIG, I2C_CONFIG_CR_I2C_SUB_ADDR_EN, 0);
    }

  //  Set the I2C Message Length
  modifyreg32(BL602_I2C_CONFIG,
              I2C_CONFIG_CR_I2C_PKT_LEN_MASK,
              (msg->length - 1) << I2C_CONFIG_CR_I2C_PKT_LEN_SHIFT);

  //  If this I2C Transfer is for I2C Sub Address...
  if (priv->subflag > 0)
    {
      //  Set the I2C Sub Address
      putreg32(priv->subaddr, BL602_I2C_SUB_ADDR);
    }
}

static void bl602_i2c_send_data(struct bl602_i2c_priv_s *priv)
{
  ...
  putreg32(temp, BL602_I2C_FIFO_WDATA);
  priv->bytes += count;
  //  Insert this
  i2cinfo("count=%d, temp=0x%x\n", count, temp);
}

static void bl602_i2c_recvdata(struct bl602_i2c_priv_s *priv)
{
  ...
  count = msg->length - priv->bytes;
  temp  = getreg32(BL602_I2C_FIFO_RDATA);
  //  Insert this
  i2cinfo("count=%d, temp=0x%x\n", count, temp);

static int bl602_i2c_transfer(struct i2c_master_s *dev,
                              struct i2c_msg_s *   msgs,
                              int                      count)
{
  ...
  for (i = 0; i < count; i++)
    {
      ...
      priv->msgid = i;
      //  Insert this before bl602_i2c_start_transfer
      i2cinfo("subflag=%d, subaddr=0x%x, sublen=%d\n", priv->subflag, priv->subaddr, priv->sublen);

mkdir nuttx
cd nuttx
git clone --recursive https://github.com/lupyuen/nuttx nuttx
git clone --recursive https://github.com/lupyuen/nuttx-apps apps

## For Linux: Change "/dev/ttyUSB0" to the BL602 / BL604 Serial Port
blflash flash nuttx.bin \
  --port /dev/ttyUSB0 

## For macOS: Change "/dev/tty.usbserial-1410" to the BL602 / BL604 Serial Port
blflash flash nuttx.bin \
  --port /dev/tty.usbserial-1410 \
  --initial-baud-rate 230400 \
  --baud-rate 230400

## For Windows: Change "COM5" to the BL602 / BL604 Serial Port
blflash flash c:\blflash\nuttx.bin --port COM5

picocom -b 115200 /dev/ttyUSB0

screen /dev/ttyUSB0 2000000

NuttShell (NSH) NuttX-10.2.0-RC0
nsh>