/*
 * Complete Project Details https://randomnerdtutorials.com
 * Modified for Raspberry Pi Pico
*/

#include <Wire.h>
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>

// ----------------------------------------
class MyBME280: public Adafruit_BME280 {

public:

  MyBME280(int cs, int mosi, int miso, int sck) : Adafruit_BME280(cs, mosi, miso, sck){};

  void readAllRegisters(uint8_t *buf) {
    buf[0] = uint8_t(0xF7);
    // i2c_dev->write_then_read(buf, 1, buf, 8);
    spi_dev->write_then_read(buf, 1, buf, 8);    // for (int i = 0; i < 8; i++) {
    //   buf[i] = read8(0xF7+i);
    // }

  };
  void readAllCoefficients(uint8_t *buf) {
    uint8_t rdbuf[1] = {0x88};
    // i2c_dev->write_then_read(rdbuf, 1, buf, 26);
    spi_dev->write_then_read(rdbuf, 1, buf, 26);    // for (int i = 0; i < 8; i++) {
    rdbuf[0] = uint8_t(0xE1);
    spi_dev->write_then_read(rdbuf, 1, buf + 26, 16);
    // int i = 0, j=0;
    // for (; i < 26; i++) {
    //   buf[i] = read8(0x88+i);
    // }
    // for (i = 0; j < 16; j++, i++) {
    //   buf[i] = read8(0xE1+j);
    // }
  };

  bme280_calib_data *calibData() { return &this->_bme280_calib;}
};

char buf[200];
bme280_calib_data *_calibData;

const char *debugHexStr(uint8_t *p, size_t c) {
    static char hb[] = "0123456789ABCDEF";
    char *pb = (char *)buf;
    //c = constrain(c, 1, 16);
    for (; c--;) {
      *pb++ = hb[(*p & 0xF0) >> 4];
      *pb++ = hb[*p & 0x0F ];
      *pb++ = ',';
      p++;
    }
    *pb = 0;
    return buf;
}
//   ------------------------------------------------------

// Updated SPI pin definitions for Raspberry Pi Pico
#define BME_SCK 18
#define BME_MISO 16
#define BME_MOSI 19
#define BME_CS 17

#define SEALEVELPRESSURE_HPA (1013.25)

// Adafruit_BME280 bme; // I2C
// Adafruit_BME280 bme(BME_CS); // hardware SPI
MyBME280 bme(BME_CS, BME_MOSI, BME_MISO, BME_SCK); // software SPI

unsigned long delayTime;

void setup() {
  Serial.begin(115200);
  Serial.println(F("BME280 test"));

  pinMode(2, OUTPUT);
  digitalWrite(2, LOW);

  bool status;
  
  #ifdef BUSIO_HAS_HW_SPI
  Serial.println("using SPI with hw: ");
  #endif
  // default settings
  // (you can also pass in a Wire library object like &Wire2)
  status = bme.begin();  
  if (!status) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1);
  }
  
  Serial.println("-- Coefficient registers --");
  static uint8_t cbuf[128];
  bme.readAllCoefficients(cbuf);
  Serial.println( debugHexStr(cbuf, 42));

  bme280_calib_data * _calibData = bme.calibData();

  Serial.print("dig_T1: "); Serial.println(_calibData->dig_T1);
  Serial.print("dig_T2: "); Serial.println(_calibData->dig_T2);
  Serial.print("dig_T3: "); Serial.println(_calibData->dig_T3);

  Serial.println("-- Default Test --");
  delayTime = 1000;

  Serial.println();
}


void loop() { 
  printValues();
  delay(delayTime);
}


uint8_t registers[8];

void printValues() {
  static uint8_t buf[128];

  Serial.print(millis());

  Serial.print(" T = ");
  Serial.print(bme.readTemperature());
  Serial.print(" *C");
  // ------ 
  Serial.print(", P = ");
  Serial.print(bme.readPressure() / 100.0F);
  Serial.print(" hPa");

  // ------ 
  Serial.print(", A = ");
  Serial.print(bme.readAltitude(SEALEVELPRESSURE_HPA));
  Serial.print(" m");

  Serial.print("H = ");
  Serial.print(bme.readHumidity());
  Serial.print(" %");

  bme.readAllRegisters(registers);
  Serial.print( ", R: "); 
  Serial.print(debugHexStr(registers, 8));

  Serial.println();
}

int32_t t_fine;
int32_t t_fine_adjust = 0;

uint32_t _read24(byte off) {
  uint8_t buffer[3];

  buffer[0] = registers[off++];
  buffer[1] = registers[off++];
  buffer[2] = registers[off++];

  return uint32_t(buffer[0]) << 16 | uint32_t(buffer[1]) << 8 |
         uint32_t(buffer[2]);
}


uint16_t _read16(byte off) {
  uint8_t buffer[2];

  buffer[0] = registers[off++];
  buffer[1] = registers[off++];

  return uint16_t(buffer[0]) << 8 | uint16_t(buffer[1]);
}

float _readTemperature(void) {
  int32_t var1, var2;

  int32_t adc_T = _read24(3);
  Serial.print(" t1: "); Serial.print(_calibData->dig_T1);
  Serial.print(" t2: "); Serial.print(_calibData->dig_T2);
  Serial.print(" t3: "); Serial.print(_calibData->dig_T3);
  Serial.println();
  Serial.print(" rt: "); Serial.print(adc_T, HEX); Serial.print(" " );
  if (adc_T == 0x800000) // value in case temp measurement was disabled
    return NAN;
  adc_T >>= 4;
  Serial.print(" srt: "); Serial.print(adc_T, HEX); Serial.print(" " ); Serial.print(adc_T); 

  var1 = (int32_t)((adc_T / 8) - ((int32_t)_calibData->dig_T1 * 2));

  Serial.println();
  Serial.print(" v1: "); Serial.print(var1);

  var1 = (var1 * ((int32_t)_calibData->dig_T2)) / 2048;

  Serial.println();
  Serial.print(" v1`: "); Serial.print(var1);

  var2 = (int32_t)((adc_T / 16) - ((int32_t)_calibData->dig_T1));

  Serial.println();
  Serial.print(" v2: "); Serial.print(var2);

  var2 = (((var2 * var2) / 4096) * ((int32_t)_calibData->dig_T3)) / 16384;

  Serial.println();
  Serial.print(" v2`: "); Serial.print(var2);

  t_fine = var1 + var2 + t_fine_adjust;

  Serial.println();
  Serial.print(" tf: "); Serial.print(t_fine);

  int32_t T = (t_fine * 5 + 128) / 256;

  Serial.println();
  Serial.print(" T: "); Serial.print(((float)T)/100.0); 
  Serial.println();

  return (float)T / 100;
}

/*!
 *   @brief  Returns the pressure from the sensor
 *   @returns the pressure value (in Pascal) read from the device
 */
float _readPressure(void) {
  int64_t var1, var2, var3, var4;

  _readTemperature(); // must be done first to get t_fine

  int32_t adc_P = _read24(0);
  if (adc_P == 0x800000) // value in case pressure measurement was disabled
    return NAN;
  adc_P >>= 4;

  var1 = ((int64_t)t_fine) - 128000;
  var2 = var1 * var1 * (int64_t)_calibData->dig_P6;
  var2 = var2 + ((var1 * (int64_t)_calibData->dig_P5) * 131072);
  var2 = var2 + (((int64_t)_calibData->dig_P4) * 34359738368);
  var1 = ((var1 * var1 * (int64_t)_calibData->dig_P3) / 256) +
         ((var1 * ((int64_t)_calibData->dig_P2) * 4096));
  var3 = ((int64_t)1) * 140737488355328;
  var1 = (var3 + var1) * ((int64_t)_calibData->dig_P1) / 8589934592;

  if (var1 == 0) {
    return 0; // avoid exception caused by division by zero
  }

  var4 = 1048576 - adc_P;
  var4 = (((var4 * 2147483648) - var2) * 3125) / var1;
  var1 = (((int64_t)_calibData->dig_P9) * (var4 / 8192) * (var4 / 8192)) /
         33554432;
  var2 = (((int64_t)_calibData->dig_P8) * var4) / 524288;
  var4 = ((var4 + var1 + var2) / 256) + (((int64_t)_calibData->dig_P7) * 16);

  float P = var4 / 256.0;

  return P;
}

/*!
 *  @brief  Returns the humidity from the sensor
 *  @returns the humidity value read from the device
 */
float _readHumidity(void) {
  int32_t var1, var2, var3, var4, var5;

  _readTemperature(); // must be done first to get t_fine

  int32_t adc_H = _read16(6);
  if (adc_H == 0x8000) // value in case humidity measurement was disabled
    return NAN;

  var1 = t_fine - ((int32_t)76800);
  var2 = (int32_t)(adc_H * 16384);
  var3 = (int32_t)(((int32_t)_calibData->dig_H4) * 1048576);
  var4 = ((int32_t)_calibData->dig_H5) * var1;
  var5 = (((var2 - var3) - var4) + (int32_t)16384) / 32768;
  var2 = (var1 * ((int32_t)_calibData->dig_H6)) / 1024;
  var3 = (var1 * ((int32_t)_calibData->dig_H3)) / 2048;
  var4 = ((var2 * (var3 + (int32_t)32768)) / 1024) + (int32_t)2097152;
  var2 = ((var4 * ((int32_t)_calibData->dig_H2)) + 8192) / 16384;
  var3 = var5 * var2;
  var4 = ((var3 / 32768) * (var3 / 32768)) / 128;
  var5 = var3 - ((var4 * ((int32_t)_calibData->dig_H1)) / 16);
  var5 = (var5 < 0 ? 0 : var5);
  var5 = (var5 > 419430400 ? 419430400 : var5);
  uint32_t H = (uint32_t)(var5 / 4096);

  return (float)H / 1024.0;
}