Initial port to new API

Author: protocentralashwin

README.md

@@ -36,6 +36,30 @@ If you have bought the breakout the connection with the Arduino board is as foll
 | PD_ALM           | NC                   |  PD sensor fault indicator  |
 | VCC              | +5v                  |  Supply voltage             |
 
+## New Features
+
+### Custom SPI Pin Support
+
+The library now supports custom SPI pins for different platforms (ESP32, ESP32-S3, ESP32-S2, ESP32-C3, ESP8266, STM32, etc.):
+
+```cpp
+// Use custom SPI pins
+AFE44XX afe44xx(csPin, pwdnPin, drdyPin, sckPin, misoPin, mosiPin);
+
+// Or configure after initialization
+afe44xx.setSPIPins(18, 19, 23);  // ESP32 example
+```
+
+**Platform Default Pins:**
+- **ESP32-S3**: SCK=12, MISO=13, MOSI=11
+- **ESP32-S2**: SCK=36, MISO=37, MOSI=35
+- **ESP32-C3**: SCK=6, MISO=5, MOSI=7
+- **ESP32**: SCK=18, MISO=19, MOSI=23
+- **ESP8266**: SCK=14, MISO=12, MOSI=13  
+- **Arduino**: SCK=13, MISO=12, MOSI=11
+
+See [Custom SPI Pins Documentation](docs/CUSTOM_SPI_PINS.md) for detailed usage examples.
+
 # Visualizing Output
 
 ![openview output](./assets/AFE4490_openview.gif)

examples/Example-1-Raw-PPG-plot-openview/Example-1-Raw-PPG-plot-openview.ino

@@ -1,121 +1,261 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 //
-//    Arduino library for the AFE4490 Pulse Oximeter Shield
+//    Arduino library for the AFE44XX Pulse Oximeter Shield - Raw PPG Plot for OpenView
+//    Updated to use the new improved library with error handling and diagnostics
 //
-//    Copyright (c) 2018 ProtoCentral
-//
-//    This example will plot the PPG signal through openview processing GUI.
+//    This example will plot the PPG signal through ProtoCentral OpenView processing GUI.
 //    GUI URL: https://github.com/Protocentral/protocentral_openview.git
 //
+//    Copyright (c) 2018 ProtoCentral
+//
 //    This software is licensed under the MIT License(http://opensource.org/licenses/MIT).
 //
-//   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 THE AUTHORS OR COPYRIGHT HOLDERS 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.
+//    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 THE AUTHORS OR COPYRIGHT HOLDERS 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.
+//
+//    For information on how to use with ProtoCentral OpenView:
+//    1. Upload this sketch to your Arduino
+//    2. Open ProtoCentral OpenView software
+//    3. Select the appropriate COM port
+//    4. Choose "AFE4490 Raw PPG" visualization mode
+//    5. Click Connect to view real-time PPG waveforms
 //
-//   For information on how to use, visit https://github.com/Protocentral/protocentral-afe4490-arduino
+//    For information on how to use, visit https://github.com/Protocentral/protocentral-afe4490-arduino
 /////////////////////////////////////////////////////////////////////////////////////////
 
-#include <SPI.h>
 #include "protocentral_afe44xx.h"
+#include "Protocentral_spo2_algorithm.h"
+#include "protocentral_hr_algorithm.h"
 
-#define AFE44XX_CS_PIN   7
-#define AFE44XX_PWDN_PIN 4
-#define AFE44XX_INTNUM   0
+// Default pins  CS=7, PWDN=4, DRDY=2
 
-#define CES_CMDIF_PKT_START_1   0x0A
-#define CES_CMDIF_PKT_START_2   0xFA
-#define CES_CMDIF_TYPE_DATA   0x02
-#define CES_CMDIF_PKT_STOP    0x0B
+#define AFE44XX_CS_PIN 10
+#define AFE44XX_PWDN_PIN 21
+#define AFE44XX_DRDY_PIN 14
 
-AFE44XX afe44xx(AFE44XX_CS_PIN, AFE44XX_PWDN_PIN);
+#define CES_CMDIF_PKT_START_1 0x0A
+#define CES_CMDIF_PKT_START_2 0xFA
+#define CES_CMDIF_TYPE_DATA 0x02
+#define CES_CMDIF_PKT_STOP 0x0B
+#define DATA_LEN 10
 
-afe44xx_data afe44xx_raw_data;
-uint8_t ppg_data_buff[20];
-int16_t ppg_wave_ir;
-uint16_t ppg_stream_cnt = 0;
-uint8_t sp02;
-uint8_t heartrate;
-bool ppg_buf_ready = false;
-bool spo2_calc_done = false;
+AFE44XX afe44xx(AFE44XX_CS_PIN, AFE44XX_PWDN_PIN, AFE44XX_DRDY_PIN);
 
-#define DATA_LEN 10
+spo2_algorithm spo2Calc;
+hr_algo hrCalc;
+
+uint16_t irBuffer[100];
+uint16_t redBuffer[100];
+uint8_t bufferIndex = 0;
+uint8_t decimationCounter = 0;
+const uint8_t DECIMATION_FACTOR = 20;
 
-char DataPacket[10];
-const char DataPacketFooter[2]={0x00, CES_CMDIF_PKT_STOP};
-const char DataPacketHeader[6] = {CES_CMDIF_PKT_START_1, CES_CMDIF_PKT_START_2, DATA_LEN, ((uint8_t)(DATA_LEN >> 8)), CES_CMDIF_TYPE_DATA};
+int32_t heartRate = 0;
+int32_t spo2 = 0;
+int8_t spo2Valid = 0;
+int8_t hrValid = 0;
 
+uint8_t ppgDataBuff[20];
+uint16_t ppgStreamCnt = 0;
+bool ppgBufReady = false;
+bool sensorInitialized = false;
+
+char dataPacket[DATA_LEN];
+const char dataPacketFooter[2] = {0x00, CES_CMDIF_PKT_STOP};
+const char dataPacketHeader[5] = {CES_CMDIF_PKT_START_1, CES_CMDIF_PKT_START_2, DATA_LEN,
+                                  ((uint8_t)(DATA_LEN >> 8)), CES_CMDIF_TYPE_DATA};
 
 void setup()
 {
-  Serial.begin(57600);
-  Serial.println("Intilaziting AFE44xx.. ");
-  
-  SPI.begin();
-  
-  afe44xx.afe44xx_init();
-  Serial.println("Inited...");
-}
+    Serial.begin(57600);
+    while (!Serial)
+        delay(10);
 
-void send_data_serial_port(void)
-{
-  for (int i = 0; i < 5; i++)
-  {
-    Serial.write(DataPacketHeader[i]); // transmit the data over USB
-  }
-  for (int i = 0; i < DATA_LEN; i++)
-  {
-    Serial.write(DataPacket[i]); // transmit the data over USB
-  }
-  for (int i = 0; i < 2; i++)
-  {
-    Serial.write(DataPacketFooter[i]); // transmit the data over USB
-  }
+    Serial.println("AFE44XX Raw PPG Data for ProtoCentral OpenView");
+    Serial.println("==============================================");
+
+    AFE44xxConfig config = AFE44XX::getDefaultConfig();
+    config.chipType = AFE44xxChipType::AFE4490;
+    config.led1Current = LEDCurrent::CURRENT_50MA;
+    config.led2Current = LEDCurrent::CURRENT_50MA;
+    config.tiaGain = TIAGain::GAIN_500K;
+    config.sampleRate = SampleRate::RATE_500HZ;
+    config.averagingFactor = 3;
+    config.enableDiagnostics = true;
+
+    Serial.println("Initializing AFE44XX...");
+    AFE44xxError error = afe44xx.begin(config);
+
+    if (error != AFE44xxError::NONE)
+    {
+        Serial.print("ERROR: Initialization failed - ");
+        Serial.println(afe44xx.getErrorString(error));
+        Serial.println("Please check connections and reset Arduino");
+
+        while (1)
+        {
+            delay(5000);
+            Serial.println("Check connections: CS=7, PWDN=4, DRDY=2, SPI pins");
+        }
+    }
+
+    error = afe44xx.performSelfTest();
+    if (error != AFE44xxError::NONE)
+    {
+        Serial.print("WARNING: Self-test failed - ");
+        Serial.println(afe44xx.getErrorString(error));
+        Serial.println("Continuing anyway...");
+    }
+    else
+    {
+        Serial.println("Self-test passed!");
+    }
+
+    hrCalc.initStatHRM();
+    sensorInitialized = true;
+
+    Serial.println("Ready! Open ProtoCentral OpenView and connect to this COM port");
+    Serial.println("Select 'AFE4490 Raw PPG' mode in OpenView");
+
+    delay(2000);
 }
 
 void loop()
 {
-    delay(8);
-    
-    afe44xx.get_AFE44XX_Data(&afe44xx_raw_data);
-    ppg_wave_ir = (int16_t)(afe44xx_raw_data.IR_data >> 8);
-    ppg_wave_ir = ppg_wave_ir;
+    if (!sensorInitialized)
+    {
+        delay(1000);
+        return;
+    }
+
+    AFE44xxData data;
+    AFE44xxError error = afe44xx.readData(data);
+
+    if (error != AFE44xxError::NONE)
+    {
+        initializeErrorPacket();
+        sendDataSerialPort();
+        delay(100);
+        return;
+    }
+
+    if (!data.dataValid)
+    {
+        delay(8);
+        return;
+    }
+
+    processSpO2Calculation(data);
+
+    prepareDataPacket(data);
 
-    ppg_data_buff[ppg_stream_cnt++] = (uint8_t)ppg_wave_ir;
-    ppg_data_buff[ppg_stream_cnt++] = (ppg_wave_ir >> 8);
+    sendDataSerialPort();
 
-    if (ppg_stream_cnt >= 19)
+    static unsigned long lastDiagTime = 0;
+    if (millis() - lastDiagTime > 10000)
     {
-      ppg_buf_ready = true;
-      ppg_stream_cnt = 0;
+        checkSensorDiagnostics();
+        lastDiagTime = millis();
     }
 
-    memcpy(&DataPacket[0], &afe44xx_raw_data.IR_data, sizeof(signed long));
-    memcpy(&DataPacket[4], &afe44xx_raw_data.RED_data, sizeof(signed long));
+    delay(8);
+}
+
+void processSpO2Calculation(const AFE44xxData &data)
+{
+    decimationCounter++;
+    if (decimationCounter >= DECIMATION_FACTOR)
+    {
+        irBuffer[bufferIndex] = (uint16_t)(data.irData >> 4);
+        redBuffer[bufferIndex] = (uint16_t)(data.redData >> 4);
+        bufferIndex = (bufferIndex + 1) % 100;
+        decimationCounter = 0;
+        
+        static uint8_t sampleCount = 0;
+        sampleCount++;
+        if (sampleCount >= 100) {
+            spo2Calc.estimate_spo2(irBuffer, 100, redBuffer, &spo2, &spo2Valid, &heartRate, &hrValid);
+            sampleCount = 0;
+        }
+    }
 
-    if (afe44xx_raw_data.buffer_count_overflow)
+    hrCalc.statHRMAlgo(data.redData);
+    if (hrCalc.HeartRate > 0)
     {
+        heartRate = hrCalc.HeartRate;
+        hrValid = 1;
+    }
+}
 
-      if (afe44xx_raw_data.spo2 == -999)
-      {
-        DataPacket[8] = 0;
-        sp02 = 0;
-        DataPacket[9] = 0;
-        heartrate = 0;
-      }
-      else
-      {
-        DataPacket[8] = afe44xx_raw_data.spo2;
-        sp02 = (uint8_t)afe44xx_raw_data.spo2;
-        DataPacket[9] = afe44xx_raw_data.heart_rate;
-        heartrate = (uint8_t) afe44xx_raw_data.heart_rate;
-        spo2_calc_done = true;
-      }
+void prepareDataPacket(const AFE44xxData &data)
+{
+    memcpy(&dataPacket[0], &data.irData, sizeof(int32_t));
+    memcpy(&dataPacket[4], &data.redData, sizeof(int32_t));
 
-      
-      afe44xx_raw_data.buffer_count_overflow = false;
+    if (spo2Valid && spo2 > 0)
+    {
+        dataPacket[8] = (uint8_t)constrain(spo2, 0, 100);
     }
-    send_data_serial_port();
+    else
+    {
+        dataPacket[8] = 0;
+    }
+
+    if (hrValid && heartRate > 0)
+    {
+        dataPacket[9] = (uint8_t)constrain(heartRate, 0, 255);
+    }
+    else
+    {
+        dataPacket[9] = 0;
+    }
+}
+
+void initializeErrorPacket()
+{
+    memset(dataPacket, 0, DATA_LEN);
+}
+
+void sendDataSerialPort()
+{
+    uint8_t fullPacket[5 + DATA_LEN + 2];
+    uint8_t idx = 0;
+    
+    memcpy(&fullPacket[idx], dataPacketHeader, 5);
+    idx += 5;
+    memcpy(&fullPacket[idx], dataPacket, DATA_LEN);
+    idx += DATA_LEN;
+    memcpy(&fullPacket[idx], dataPacketFooter, 2);
+    
+    Serial.write(fullPacket, sizeof(fullPacket));
 }
+
+void checkSensorDiagnostics()
+{
+    AFE44xxDiagnostics diag;
+    AFE44xxError error = afe44xx.getDiagnostics(diag);
+
+    if (error != AFE44xxError::NONE)
+    {
+        return;
+    }
+
+    if (diag.ledFault || diag.pdShort || diag.pdOpen || diag.gainError)
+    {
+        afe44xx.clearFaults();
+    }
+
+    if (diag.ambientLight > 2000)
+    {
+        afe44xx.setLEDCurrent(1, LEDCurrent::CURRENT_75MA);
+        afe44xx.setLEDCurrent(2, LEDCurrent::CURRENT_75MA);
+    }
+    else if (diag.ambientLight < 100)
+    {
+        afe44xx.setLEDCurrent(1, LEDCurrent::CURRENT_25MA);
+        afe44xx.setLEDCurrent(2, LEDCurrent::CURRENT_25MA);
+    }
+}