Diff: HSP/Devices/MAX30101/MAX30101/MAX30101.cpp

Revision:

0:e4a10ed6eb92

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/HSP/Devices/MAX30101/MAX30101/MAX30101.cpp	Tue Oct 25 15:22:11 2016 +0000
@@ -0,0 +1,703 @@
+
+/*******************************************************************************
+ * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
+ * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Maxim Integrated
+ * Products, Inc. shall not be used except as stated in the Maxim Integrated
+ * Products, Inc. Branding Policy.
+ *
+ * The mere transfer of this software does not imply any licenses
+ * of trade secrets, proprietary technology, copyrights, patents,
+ * trademarks, maskwork rights, or any other form of intellectual
+ * property whatsoever. Maxim Integrated Products, Inc. retains all
+ * ownership rights.
+ *******************************************************************************
+ */
+
+#include "mbed.h"
+#include "MAX30101.h"
+
+MAX30101 *MAX30101::instance = NULL;
+
+//******************************************************************************
+MAX30101::MAX30101(PinName sda, PinName scl, int slaveAddress): 
+          slaveAddress(slaveAddress) {
+  i2c = new I2C(sda, scl);
+  i2c_owner = true;
+  i2c->frequency(400000);
+  onInterruptCallback = NULL;
+  onDataAvailableCallback = NULL;
+  instance = this;
+}
+
+//******************************************************************************
+MAX30101::MAX30101(I2C *_i2c, int slaveAddress) : 
+          slaveAddress(slaveAddress) {
+  i2c = _i2c;
+  i2c_owner = false;
+  i2c->frequency(400000);
+  onInterruptCallback = NULL;
+  onDataAvailableCallback = NULL;
+  instance = this;
+}
+
+//******************************************************************************
+MAX30101::~MAX30101(void) {
+  if (i2c_owner) {
+    delete i2c;
+  }
+}
+
+//******************************************************************************
+int MAX30101::int_handler(void) {
+  uint16_t index, i;
+  uint16_t rx_bytes, second_rx_bytes;
+  char temp_int;
+  char temp_frac;
+  uint16_t num_active_led;
+  uint32_t sample;
+  int loop = 1;
+  static uint8_t cntr_int = 0;
+
+
+  cntr_int++;
+
+  while (loop) {
+    if (i2c_reg_read(REG_INT_STAT_1, &max30101_Interrupt_Status_1.all) != 0) // Read Interrupt flag bits
+    {
+      return -1;
+    }
+
+    if (i2c_reg_read(REG_INT_STAT_2, &max30101_Interrupt_Status_2.all) != 0) // Read Interrupt flag bits
+    {
+      return -1;
+    }
+
+    if (max30101_Interrupt_Status_1.bit.a_full) {
+      /* Read the sample(s) */
+      char reg = REG_FIFO_DATA;
+
+      num_active_led = 0;
+
+      if (max30101_mode_configuration.bit.mode == 0x02) // Heart Rate mode, i.e. 1 led
+      {
+        num_active_led = 1;
+      } else if (max30101_mode_configuration.bit.mode == 0x03) // SpO2 mode, i.e. 2 led
+      {
+        num_active_led = 2;
+      } else if (max30101_mode_configuration.bit.mode == 0x07) // Multi-LED mode, i.e. 1-4 led
+      {
+        if (max30101_multiLED_mode_ctrl_1.bit.slot1 != 0) {
+          num_active_led++;
+        }
+
+        if (max30101_multiLED_mode_ctrl_1.bit.slot2 != 0) {
+          num_active_led++;
+        }
+
+        if (max30101_multiLED_mode_ctrl_2.bit.slot3 != 0) {
+          num_active_led++;
+        }
+
+        if (max30101_multiLED_mode_ctrl_2.bit.slot4 != 0) {
+          num_active_led++;
+        }
+      }
+               // 3bytes/LED x Number of Active LED x FIFO level selected
+        rx_bytes =  3 * num_active_led * (32-max30101_fifo_configuration.bit.fifo_a_full);   
+
+      second_rx_bytes = rx_bytes;
+
+      /*  The FIFO Size is determined by the Sample size.  The number of bytes
+       * in a Sample is dictated by number of LED's
+       *
+       *   #LED Selected     Bytes in "1" sample
+       *        1                  3
+       *        2                  6
+       *        3                  9
+       *        4                  12
+       *
+       *  The I2C API function limits the number of bytes to read to 256 (i.e.
+       * char).  Therefore, when set for
+       *  Multiple LED's and the FIFO size is set to 32.  It would mean there is
+       * more than 256 bytes.
+       *  In that case two I2C reads have to be made.  However It is important
+       * to not that each "Sample"
+       *  must be read completely and reading only partial number of bytes from
+       * a sample will result in erroneous data.
+       *
+       *  For example:
+       *  Num of LED selected = 3 and FIFO size is set to 32 (i.e. 0 value in
+       * register), then the number of bytes
+       *  will be 3bytes/Led * 3led's * 32 = 288 bytes in all.  Since there are
+       * 3 LED's each sample will contain (3 * 3)
+       *  9bytes.  Therefore Sample 1 = 9bytes, Sample 2 = 18,... Sample 28 =
+       * 252.  Therefore the first
+       *  I2C read should be 252 bytes and the second read should be 288-252 =
+       * 36.
+       *
+       *  It turns out that this size issue comes up only when number of LED
+       * selected is 3 or 4 and choosing 252bytes
+       *  for the first I2C read would work for both Number of LED selection.
+       */
+
+      if (rx_bytes <= CHUNK_SIZE) {
+        I2CM_Read(slaveAddress, &reg, 1, &max30101_rawData[0],
+                  (char)rx_bytes /*total_databytes_1*/);
+      } else {
+        I2CM_Read(slaveAddress, &reg, 1, &max30101_rawData[0], CHUNK_SIZE);
+
+        second_rx_bytes = second_rx_bytes - CHUNK_SIZE;
+        I2CM_Read(slaveAddress, &reg, 1, &max30101_rawData[CHUNK_SIZE],
+                  (char)second_rx_bytes);
+      }
+
+      index = 0;
+
+      for (i = 0; i < rx_bytes; i += 3) {
+        sample = ((uint32_t)(max30101_rawData[i] & 0x03) << 16) | (max30101_rawData[i + 1] << 8) | max30101_rawData[i + 2];
+
+        // Right shift the data based on the LED_PW setting
+        sample = sample >>
+                 (3 -
+                  max30101_spo2_configuration.bit.led_pw); // 0=shift 3, 1=shift 2, 2=shift 1, 3=no shift
+
+        max30101_buffer[index++] = sample;
+      }
+
+      onDataAvailableCallback(MAX30101_OXIMETER_DATA + num_active_led, max30101_buffer, index);
+    }
+
+// This interrupt handles the proximity interrupt, for future enhancements
+#if 0
+   if(max30101_Interrupt_Status_1.bit.prox_int)
+     {
+     max30101_mode_configuration.full=0;
+     max30101_mode_configuration.bit.mode=0x03;     // SpO2 mode
+     i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.full);
+
+     }
+#endif
+
+    // This interrupt handles the temperature interrupt
+    if (max30101_Interrupt_Status_2.bit.die_temp_rdy) {
+      char reg;
+
+      reg = REG_TINT;
+      if (I2CM_Read(slaveAddress, &reg, 1, &temp_int, 1) != 0) {
+        return -1;
+      }
+
+      reg = REG_TFRAC;
+      if (I2CM_Read(slaveAddress, &reg, 1, &temp_frac, 1) != 0) {
+        return -1;
+      }
+
+      max30101_final_temp = (int8_t)temp_int + 0.0625 * temp_frac;
+
+      if (i2c_reg_write(REG_TEMP_EN, 0x00) != 0) // Die Temperature Config, Temp disable... after one read...
+      {
+        return -1;
+      }
+    }
+
+    if (i2c_reg_read(REG_INT_STAT_1, &max30101_Interrupt_Status_1.all) != 0) // Read Interrupt flag bits
+    {
+      return -1;
+    }
+    if (max30101_Interrupt_Status_1.bit.a_full != 1) {
+      loop = 0;
+    }
+  }
+
+  interruptPostCallback();
+
+
+  return 0;
+}
+
+//******************************************************************************
+int MAX30101::SpO2mode_init(uint8_t fifo_waterlevel_mark, uint8_t sample_avg,
+                            uint8_t sample_rate, uint8_t pulse_width,
+                            uint8_t red_led_current, uint8_t ir_led_current) {
+
+  char status;
+
+  max30101_mode_configuration.all = 0;
+  max30101_mode_configuration.bit.reset = 1;
+  if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) // Reset the device, Mode = don't use...
+  {
+    return -1;
+  }
+
+  /* Give it some settle time (100ms) */
+  wait(1.0 / 10.0); // Let things settle down a bit
+
+  max30101_fifo_configuration.all = 0;
+  max30101_fifo_configuration.bit.smp_ave = sample_avg; // Sample averaging;
+  max30101_fifo_configuration.bit.fifo_roll_over_en = 1; // FIFO Roll over enabled
+  max30101_fifo_configuration.bit.fifo_a_full = fifo_waterlevel_mark; // Interrupt when certain level is filled
+  if (i2c_reg_write(REG_FIFO_CFG, max30101_fifo_configuration.all) != 0) {
+    return -1;
+  }
+
+  max30101_spo2_configuration.bit.spo2_adc_rge = 0x2; // ADC Range 8192 fullscale
+  max30101_spo2_configuration.bit.spo2_sr = sample_rate; // 100 Samp/sec.
+  max30101_spo2_configuration.bit.led_pw = pulse_width; // Pulse Width=411us and ADC Resolution=18
+  if (i2c_reg_write(REG_SPO2_CFG, max30101_spo2_configuration.all) != 0) {
+    return -1;
+  }
+
+  max30101_led1_pa = red_led_current; // RED LED current
+  if (i2c_reg_write(REG_LED1_PA, max30101_led1_pa) != 0) {
+    return -1;
+  }
+
+  max30101_led2_pa = ir_led_current; // IR LED current
+  if (i2c_reg_write(REG_LED2_PA, max30101_led2_pa) != 0) {
+    return -1;
+  }
+
+  /************/
+
+  if (i2c_reg_read(REG_INT_STAT_1, &status) != 0) //  Clear INT1 by reading the status
+  {
+    return -1;
+  }
+
+  if (i2c_reg_read(REG_INT_STAT_2, &status) != 0) //  Clear INT2 by reading the status
+  {
+    return -1;
+  }
+
+  if (i2c_reg_write(REG_FIFO_W_PTR, 0x00) != 0) //  Clear FIFO ptr
+  {
+    return -1;
+  }
+
+  if (i2c_reg_write(REG_FIFO_OVF_CNT, 0x00) != 0) //  Clear FIFO ptr
+  {
+    return -1;
+  }
+
+  if (i2c_reg_write(REG_FIFO_R_PTR, 0x00) != 0) //  Clear FIFO ptr
+  {
+    return -1;
+  }
+
+  max30101_Interrupt_Enable_1.all = 0;
+  max30101_Interrupt_Enable_1.bit.a_full_en = 1; //  Enable FIFO almost full interrupt
+  if (i2c_reg_write(REG_INT_EN_1, max30101_Interrupt_Enable_1.all) != 0) {
+    return -1;
+  }
+
+  max30101_mode_configuration.all = 0;
+  max30101_mode_configuration.bit.mode = 0x03; // SpO2 mode
+  if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) {
+    return -1;
+  }
+
+  return 0;
+}
+
+//******************************************************************************
+int MAX30101::SpO2mode_stop(void) {
+
+  max30101_Interrupt_Enable_1.all = 0;
+  max30101_Interrupt_Enable_1.bit.a_full_en = 0; //  Disable FIFO almost full interrupt
+  if (i2c_reg_write(REG_INT_EN_1, max30101_Interrupt_Enable_1.all) != 0) {
+    return -1;
+  }
+
+  max30101_mode_configuration.all = 0;
+  max30101_mode_configuration.bit.mode = 0x00; // SpO2 mode off
+  if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) {
+    return -1;
+  }
+
+  max30101_led1_pa = 0; // RED LED current, 0.0
+  if (i2c_reg_write(REG_LED1_PA, max30101_led1_pa) != 0) {
+    return -1;
+  }
+
+  max30101_led2_pa = 0; // IR LED current, 0.0
+  if (i2c_reg_write(REG_LED2_PA, max30101_led2_pa) != 0) {
+    return -1;
+  }
+
+  return 0;
+}
+
+//******************************************************************************
+int MAX30101::HRmode_init(uint8_t fifo_waterlevel_mark, uint8_t sample_avg,
+                          uint8_t sample_rate, uint8_t pulse_width,
+                          uint8_t red_led_current) {
+
+  /*uint8_t*/ char status;
+
+  max30101_mode_configuration.all = 0;
+  max30101_mode_configuration.bit.reset = 1;
+  if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) // Reset the device, Mode = don't use...
+  {
+    return -1;
+  }
+
+  /* Give it some settle time (100ms) */
+  wait(1.0 / 10.0); // Let things settle down a bit
+
+  max30101_fifo_configuration.all = 0;
+  max30101_fifo_configuration.bit.smp_ave = sample_avg; // Sample averaging;
+  max30101_fifo_configuration.bit.fifo_roll_over_en = 1; // FIFO Roll over enabled
+  max30101_fifo_configuration.bit.fifo_a_full = fifo_waterlevel_mark; // Interrupt when certain level is filled
+  if (i2c_reg_write(REG_FIFO_CFG, max30101_fifo_configuration.all) != 0) {
+    return -1;
+  }
+
+  max30101_spo2_configuration.bit.spo2_adc_rge = 0x2; // ADC Range 8192 fullscale
+  max30101_spo2_configuration.bit.spo2_sr = sample_rate; // 100 Samp/sec.
+  max30101_spo2_configuration.bit.led_pw = pulse_width; // Pulse Width=411us and ADC Resolution=18
+  if (i2c_reg_write(REG_SPO2_CFG, max30101_spo2_configuration.all) != 0) {
+    return -1;
+  }
+
+  max30101_led1_pa = red_led_current; // RED LED current, 0.0
+  if (i2c_reg_write(REG_LED1_PA, max30101_led1_pa) != 0) {
+    return -1;
+  }
+
+  /************/
+
+  if (i2c_reg_read(REG_INT_STAT_1, &status) != 0) //  Clear INT1 by reading the status
+  {
+    return -1;
+  }
+
+  if (i2c_reg_read(REG_INT_STAT_2, &status) != 0) //  Clear INT2 by reading the status
+  {
+    return -1;
+  }
+
+  if (i2c_reg_write(REG_FIFO_W_PTR, 0x00) != 0) //  Clear FIFO ptr
+  {
+    return -1;
+  }
+
+  if (i2c_reg_write(REG_FIFO_OVF_CNT, 0x00) != 0) //  Clear FIFO ptr
+  {
+    return -1;
+  }
+
+  if (i2c_reg_write(REG_FIFO_R_PTR, 0x00) != 0) //  Clear FIFO ptr
+  {
+    return -1;
+  }
+
+  max30101_Interrupt_Enable_1.all = 0;
+  max30101_Interrupt_Enable_1.bit.a_full_en = 1;
+  // max30101_Interrupt_Enable_1.bit.prox_int_en=0;   //  Enable Proximity
+  // Interrupt
+  if (i2c_reg_write(REG_INT_EN_1, max30101_Interrupt_Enable_1.all) != 0) {
+    return -1;
+  }
+
+  max30101_mode_configuration.all = 0;
+  max30101_mode_configuration.bit.mode = 0x02; // HR mode
+  if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) {
+    return -1;
+  }
+
+  return 0;
+}
+
+//******************************************************************************
+int MAX30101::HRmode_stop(void) {
+
+  max30101_Interrupt_Enable_1.all = 0;
+  max30101_Interrupt_Enable_1.bit.a_full_en = 0; //  Disable FIFO almost full interrupt
+  if (i2c_reg_write(REG_INT_EN_1, max30101_Interrupt_Enable_1.all) != 0) {
+    return -1;
+  }
+
+  max30101_mode_configuration.all = 0;
+  max30101_mode_configuration.bit.mode = 0x00; // HR mode off
+  if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) {
+    return -1;
+  }
+
+  max30101_led1_pa = 0; // RED LED current, 0.0
+  if (i2c_reg_write(REG_LED1_PA, max30101_led1_pa) != 0) {
+    return -1;
+  }
+
+  return 0;
+}
+
+//******************************************************************************
+int MAX30101::Multimode_init(uint8_t fifo_waterlevel_mark, uint8_t sample_avg,
+                             uint8_t sample_rate, uint8_t pulse_width,
+                             uint8_t red_led_current, uint8_t ir_led_current,
+                             uint8_t green_led_current, uint8_t slot_1,
+                             uint8_t slot_2, uint8_t slot_3, uint8_t slot_4) {
+  char status;
+  max30101_mode_configuration.all = 0;
+  max30101_mode_configuration.bit.reset = 1;
+  if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) // Reset the device, Mode = don't use...
+  {
+    return -1;
+  }
+
+  /* Give it some settle time (100ms) */ // Let things settle down a bit
+  wait(1.0 / 10.0);
+
+  max30101_fifo_configuration.all = 0;
+  max30101_fifo_configuration.bit.smp_ave = sample_avg; // Sample averaging;
+  max30101_fifo_configuration.bit.fifo_roll_over_en = 1; // FIFO Roll over enabled
+  max30101_fifo_configuration.bit.fifo_a_full =
+      fifo_waterlevel_mark; // Interrupt when certain level is filled
+  if (i2c_reg_write(REG_FIFO_CFG, max30101_fifo_configuration.all) != 0) {
+    return -1;
+  }
+
+  max30101_spo2_configuration.bit.spo2_adc_rge = 0x2; // ADC Range 8192 fullscale
+  max30101_spo2_configuration.bit.spo2_sr = sample_rate; // 100 Samp/sec.
+  max30101_spo2_configuration.bit.led_pw = pulse_width; // Pulse Width=411us and ADC Resolution=18
+  if (i2c_reg_write(REG_SPO2_CFG, max30101_spo2_configuration.all) != 0) {
+    return -1;
+  }
+
+  max30101_led1_pa = red_led_current; // RED LED current
+  if (i2c_reg_write(REG_LED1_PA, max30101_led1_pa) != 0) {
+    return -1;
+  }
+
+  max30101_led2_pa = ir_led_current; // IR LED current
+  if (i2c_reg_write(REG_LED2_PA, max30101_led2_pa) != 0) {
+    return -1;
+  }
+
+  max30101_led3_pa = green_led_current; // Green LED current
+  if (i2c_reg_write(REG_LED3_PA, max30101_led3_pa) != 0) {
+    return -1;
+  }
+
+  // 0x01=Red(LED1), 0x02=IR(LED2), 0x03=Green(LED3) : Use LEDn_PA to adjust the intensity
+  // 0x05=Red      , 0x06=IR      , 0x07=Green       : Use PILOT_PA to adjust the intensity DO NOT USE THIS ROW...
+
+  max30101_multiLED_mode_ctrl_1.bit.slot1 = slot_1;
+  max30101_multiLED_mode_ctrl_1.bit.slot2 = slot_2;
+  if (i2c_reg_write(REG_SLT2_SLT1, max30101_multiLED_mode_ctrl_1.all)) {
+    return -1;
+  }
+
+  max30101_multiLED_mode_ctrl_2.all = 0;
+  max30101_multiLED_mode_ctrl_2.bit.slot3 = slot_3;
+  max30101_multiLED_mode_ctrl_2.bit.slot4 = slot_4;
+  if (i2c_reg_write(REG_SLT4_SLT3, max30101_multiLED_mode_ctrl_2.all)) {
+    return -1;
+  }
+
+  /************/
+
+  if (i2c_reg_read(REG_INT_STAT_1, &status) != 0) //  Clear INT1 by reading the status
+  {
+    return -1;
+  }
+
+  if (i2c_reg_read(REG_INT_STAT_2, &status) != 0) //  Clear INT2 by reading the status
+  {
+    return -1;
+  }
+
+  if (i2c_reg_write(REG_FIFO_W_PTR, 0x00) != 0) //  Clear FIFO ptr
+  {
+    return -1;
+  }
+
+  if (i2c_reg_write(REG_FIFO_OVF_CNT, 0x00) != 0) //  Clear FIFO ptr
+  {
+    return -1;
+  }
+
+  if (i2c_reg_write(REG_FIFO_R_PTR, 0x00) != 0) //  Clear FIFO ptr
+  {
+    return -1;
+  }
+
+  max30101_Interrupt_Enable_1.all = 0;
+  max30101_Interrupt_Enable_1.bit.a_full_en = 1; //  Enable FIFO almost full interrupt
+  if (i2c_reg_write(REG_INT_EN_1, max30101_Interrupt_Enable_1.all) != 0) {
+    return -1;
+  }
+
+  max30101_mode_configuration.all = 0;
+  max30101_mode_configuration.bit.mode = 0x07; // Multi-LED mode
+  if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) {
+    return -1;
+  }
+
+  return 0;
+}
+
+//******************************************************************************
+int MAX30101::Multimode_stop(void) {
+
+  max30101_Interrupt_Enable_1.all = 0;
+  max30101_Interrupt_Enable_1.bit.a_full_en = 0; //  Disable FIFO almost full interrupt
+  if (i2c_reg_write(REG_INT_EN_1, max30101_Interrupt_Enable_1.all) != 0) {
+    return -1;
+  }
+
+  max30101_mode_configuration.all = 0;
+  max30101_mode_configuration.bit.mode = 0x00; // Multi-LED mode off
+  if (i2c_reg_write(REG_MODE_CFG, max30101_mode_configuration.all) != 0) {
+    return -1;
+  }
+
+  max30101_led1_pa = 0; // RED LED current, 0.0
+  if (i2c_reg_write(REG_LED1_PA, max30101_led1_pa) != 0) {
+    return -1;
+  }
+
+  max30101_led2_pa = 0; // IR LED current, 0.0
+  if (i2c_reg_write(REG_LED2_PA, max30101_led2_pa) != 0) {
+    return -1;
+  }
+
+  max30101_led3_pa = 0; // Green LED current, 0.0
+  if (i2c_reg_write(REG_LED3_PA, max30101_led3_pa) != 0) {
+    return -1;
+  }
+  return 0;
+}
+
+//******************************************************************************
+int MAX30101::tempread(void) {
+  max30101_Interrupt_Enable_2.all = 0;
+  max30101_Interrupt_Enable_2.bit.die_temp_rdy_en = 1; // Enable the Temp Rdy;
+  if (i2c_reg_write(REG_INT_EN_2, 0x02) != 0) // Interrupt Enable 2, Temperature Interrupt
+  {
+    return -1;
+  }
+
+  if (i2c_reg_write(REG_TEMP_EN, 0x01) != 0) // Die Temperature Config, Temp enable...
+  {
+    return -1;
+  }
+  return 0;
+}
+
+//******************************************************************************
+int MAX30101::i2c_reg_write(MAX30101_REG_map_t reg, char value) {
+  char cmdData[2] = {reg, value};
+
+  if (I2CM_Write(slaveAddress, NULL, 0, cmdData, 2) != 0 /*2*/) {
+    return -1;
+  }
+
+  return 0;
+}
+
+//******************************************************************************
+int MAX30101::i2c_reg_read(MAX30101_REG_map_t reg, char *value) {
+  if (I2CM_Read(slaveAddress, (char *)&reg, 1, value, 1) != 0 /*1*/) {
+    return -1;
+  }
+
+  return 0;
+}
+
+/**
+* @brief Read from an I2C device
+* @param slaveAddress slave address to use with transaction
+* @param writeData pointer of data to write
+* @param writeCount number of data to write
+* @param readData pointer to buffer to read to
+* @param readCount number of bytes to read
+*/
+int MAX30101::I2CM_Read(int slaveAddress, char *writeData, char writeCount,
+                        char *readData, char readCount) {
+  if (writeData != NULL && writeCount != 0) {
+    i2c->write(slaveAddress, writeData, writeCount, true);
+  }
+  if (readData != NULL && readCount != 0) {
+    i2c->read(slaveAddress, readData, readCount);
+  }
+  return 0;
+}
+
+/**
+* @brief Write to an I2C device
+* @param slaveAddress slave address to use with transaction
+* @param writeData pointer of data to write
+* @param writeCount1 number of data to write
+* @param writeData2 pointer to buffer to read to
+* @param writeCount2 number of bytes to read
+*/
+int MAX30101::I2CM_Write(int slaveAddress, char *writeData1, char writeCount1,
+                         char *writeData2, char writeCount2) {
+  if (writeData1 != NULL && writeCount1 != 0) {
+    i2c->write(slaveAddress, writeData1, writeCount1);
+  }
+  if (writeData2 != NULL && writeCount2 != 0) {
+    i2c->write(slaveAddress, writeData2, writeCount2);
+  }
+  return 0;
+}
+
+//******************************************************************************
+void MAX30101::onDataAvailable(DataCallbackFunction _onDataAvailable) {
+  onDataAvailableCallback = _onDataAvailable;
+}
+
+/**
+* @brief Used to notify an external function that interrupt data is available
+* @param id type of data available
+* @param buffer 32-bit buffer that points to the data
+* @param length length of 32-bit elements available
+*/
+void MAX30101::dataAvailable(uint32_t id, uint32_t *buffer, uint32_t length) {
+  if (onDataAvailableCallback != NULL) {
+    (*onDataAvailableCallback)(id, buffer, length);
+  }
+}
+
+//******************************************************************************
+void MAX30101::onInterrupt(InterruptFunction _onInterrupt) {
+  onInterruptCallback = _onInterrupt;
+}
+
+/**
+* @brief Executed on interrupt
+* @param id type of data available
+* @param buffer 32-bit buffer that points to the data
+* @param length length of 32-bit elements available
+*/
+void MAX30101::interruptPostCallback(void) {
+  if (onInterruptCallback != NULL) {
+    (*onInterruptCallback)();
+  }
+}
+
+int max30101_enableInterrupts = 0;
+/**************************************************************************************************************/
+void MAX30101MidIntHandler(void) { 
+  MAX30101::instance->int_handler(); 
+}