#include<stdio.h>
#include<stdlib.h>
#include<Wire.h>
const int Resetz = 15;
const int ADC_RDY = 4;
#define HRM_ADD 0x58 //Slave device
#define adc_step_size 0.0000057220458984
#define MAX 500
#define TEN_MIN 1000000
#define counting 500
double adc_ ;
double arr_0x2A[MAX], arr_0x2B[MAX], arr_0x2C[MAX], arr_0x2D[MAX], arr_0x2E[MAX], arr_0x2F[MAX], arr_R_40[MAX];

void setup() {
  Wire.begin();
  Serial.begin(115200);
  pinMode(Resetz, OUTPUT);
  pinMode(ADC_RDY, INPUT);
  pinMode(Resetz, OUTPUT);
  pinMode(ADC_RDY, INPUT);
  HRM_power_on();     //Powering on the AFE and trigger also
  Reset_all_Reg__to_zero(); //Resetting all registers
  HRM_power_down();   //Powering down
  delay(1000);
  HRM_power_on();     //Powering on the AFE and trigger also
  AFE_Reg_Init();     //Enabling Register Write
  set_ALL_reg();     //Writting to all registers
  HRM_power_down();   //Powering down
  delay(1000);
}

void loop() {
  // put your main code here, to run repeatedly:
  HRM_power_on();     //Powering on the AFE and trigger also
  AFE_Reg_Init();     //Enabling Register Write
  set_ALL_reg();     //Writting to all registers
  delay(100);
  AFE_Enable_Read (); // Read Enable
  Serial.println("ADC_RDY input>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
  int adc = digitalRead(ADC_RDY);
  Serial.println(adc);
  if (adc > 0) {
    Serial.println("ADC_RDY input available");
  }
  Serial.println("ADC_RDY input>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
  int count = 0;
  while (count <= counting) {
    //Serial.print("0x2A :");
    adc_ = AFE_Reg_Read(0x2A); adc_ *= adc_step_size; adc_ *= 0.1;
    //Serial.print(adc_, HEX);
    arr_0x2A[count] = adc_; //Stoaring values in array
    delay(10);
    //Serial.print("0x2B :");
    adc_ = AFE_Reg_Read(0x2B); adc_ *= adc_step_size; adc_ *= 0.1;
    //Serial.print(adc_, HEX);
    arr_0x2B[count] = adc_; //Stoaring values in array
    delay(10);
    // Serial.print("0x2C :");
    adc_ = AFE_Reg_Read(0x2C); adc_ *= adc_step_size; adc_ *= 0.1;
    // Serial.print(adc_, HEX);
    arr_0x2C[count] = adc_; //Stoaring values in array
    delay(10);
    // Serial.print("0x2D :");
    adc_ = AFE_Reg_Read(0x2D); adc_ *= adc_step_size; adc_ *= 0.1;
    // Serial.print(adc_, HEX);
    arr_0x2D[count] = adc_; //Stoaring values in array
    delay(10);
    // Serial.print("0x2E :");
    adc_ = AFE_Reg_Read(0x2E); adc_ *= adc_step_size; adc_ *= 0.1;
    // Serial.print(adc_, HEX);
    arr_0x2E[count] = adc_; //Stoaring values in array
    delay(10);
    // Serial.print("0x2F :");
    adc_ = AFE_Reg_Read(0x2F); adc_ *= adc_step_size; adc_ *= 0.1;
    //  Serial.print(adc_, HEX);
    arr_0x2F[count] = adc_; //Stoaring values in array
    delay(10);
    // Serial.print("0x40 :");
    adc_ = AFE_Reg_Read(0x40); adc_ *= adc_step_size; adc_ *= 0.1;
    // Serial.print(adc_, HEX);
    arr_R_40[count] = adc_; //Stoaring values in array
    Serial.println("\n");
    count++;
    delay(10);
  }
  //AFE_Reg_Read(47);
  //  AFE_Disable_Read ();
  HRM_power_down();   //Powering down
  Serial.println("#############\n");
  for (int k = 0; k <= counting; k++)
  {
    Serial.print("arr_0x2A ::"); Serial.println(arr_0x2A[k], DEC);
    Serial.print("arr_0x2B ::"); Serial.println(arr_0x2B[k], DEC);
    Serial.print("arr_0x2C ::"); Serial.println(arr_0x2C[k], DEC);
    Serial.print("arr_0x2D ::"); Serial.println(arr_0x2D[k], DEC);
    Serial.print("arr_0x2E ::"); Serial.println(arr_0x2E[k], DEC);
    Serial.print("arr_0x2F ::"); Serial.println(arr_0x2F[k], DEC);
    Serial.print("arr_R_40 ::"); Serial.println(arr_R_40[k], DEC);
    //delay(10);
  }
  Serial.println(" ");
  delay(TEN_MIN);
}
/****************************************
        HRM powering on
*****************************************/
void HRM_power_on() {
  Serial.println("HRM_power_on");
  delay(1000);
  digitalWrite(Resetz, HIGH);//AFE init
  delay(10);
  digitalWrite(Resetz, LOW);
  delayMicroseconds(35);//25us to 50 us.
  digitalWrite(Resetz, HIGH);// Reset internal registers by setting RESETZ = LOW for 25 - 50 us
  delay(10);
}
/****************************************************************
    Power Down by setting the RESETZ pin to LOW for more than 200 us
****************************************************************/
void HRM_power_down() {
  Serial.println("\nHRM_power_down");
  delay(100);
  digitalWrite(Resetz, LOW);
  delayMicroseconds(200);
}
/********************************************
      Reegister Write mode
*********************************************/
void AFE_Reg_Init() {
  Serial.println("Setting up INIT registers");
  delay(1000);
  Wire.beginTransmission(HRM_ADD);
  AFE_Reg_Write(0x00, 0x000000);
}
/**********************************************************************************************************/
/*                              AFE4404_Enable_Read                                                       */
/**********************************************************************************************************/
void AFE_Enable_Read ()         //Prohibit writing to registers
{
  //Serial.println("AFE_Reg_read");
  //delay(10);
  byte configData[3];
  configData[0] = 0x00;
  configData[1] = 0x00;
  configData[2] = 0x01;
  i2c_write(0x00, configData);
}
/**********************************************************************************************************/
/*                              AFE4404_Disable_Read                                                      */
/**********************************************************************************************************/
void AFE_Disable_Read ()        //Permitt writing to registers
{
  // Serial.println("AFE_Reg_disable read");
  delay(10);
  byte configData[3];
  configData[0] = 0x00;
  configData[1] = 0x00;
  configData[2] = 0x00;
  i2c_write ( 0x00, configData);
}
/********************************************
      Reegister Writting
*********************************************/
void AFE_Reg_Write(int reg_address, unsigned long  data1)
{
  byte configData[3];
  configData[0] = (byte)(data1 >> 16);
  configData[1] = (byte)(((data1 & 0x00FFFF) >> 8));
  configData[2] = (byte)(((data1 & 0x0000FF)));
  i2c_write(reg_address, configData);
}

char i2c_write(int reg_address, byte configData[])
{
  /*24 bit data writtern on register in MSB first pattern */
  int trans_end = 0;
  Wire.beginTransmission(HRM_ADD);
  // Serial.println(reg_address);
  Wire.write(reg_address);
  // Serial.print(configData[0]);
  Wire.write(configData[0]);//         //MSB
  // Serial.print(configData[1]);
  Wire.write(configData[1]);
  //  Serial.print(configData[2]);
  Wire.write(configData[2]);      //LSB
  Wire.endTransmission();
  delay(10);
  // Serial.println(" ");
  return (trans_end);
}


/*********************************************************************************************************/
/*                                   AFE4404_Reg_Read                                                    */
/*********************************************************************************************************/
signed long AFE_Reg_Read(int reg_address)
{
  byte configData[3];
  signed long retVal;
  i2c_read (reg_address, configData);
  retVal = configData[0];
  retVal = (retVal << 8) | configData[1];
  retVal = (retVal << 8) | configData[2];
  //Serial.println("#########HEX_value##########");
  Serial.print(reg_address); Serial.print(" :: "); Serial.println(retVal);
  //Serial.println("#########HEX_value##########");
  //delay(20);
  if (reg_address >= 0x2A && reg_address <= 0x40)
  {
    if (retVal & 0x00200000)  // check if the ADC value is positive or negative
    {
      retVal &= 0x003FFFFF;   // convert it to a 22 bit value
      Serial.print(reg_address); Serial.print("::22 bit Conversion cos -ve:: "); Serial.println(retVal);
      return (retVal ^ 0xFFC00000);
    }
  }
  //  Serial.println("#########retVal ^ 0xFFC00000##########");
  //  Serial.print(reg_address); Serial.print("::"); Serial.println(retVal);
  // Serial.println("#########Conversion_value##########");
  //delay(10);
  return retVal;
}
char i2c_read(int reg_address, byte *read_Data) {
  int trans_end = 0;
  int byteCount = 3;
  Wire.beginTransmission(HRM_ADD);
  Wire.write(reg_address);
  Wire.endTransmission();
  Wire.requestFrom(HRM_ADD, 3);
  //delay(10);
  while (Wire.available() && (byteCount != 0))
  {
    *read_Data++ = Wire.read();
    byteCount--;
  }
  return (trans_end);
}

/*********************************************************
              Setting up All write registers
**********************************************************/
void set_ALL_reg()
{
  //Waveform
  //AFE_Reg_Write (00, 0x000000);//1h
  AFE_Reg_Write (0x01, 0x000064);//1h
  AFE_Reg_Write (0x02, 0x00018E);//2h
  AFE_Reg_Write (0x03, 0x000320);//3h
  AFE_Reg_Write (0x04, 0x0004AE);//4h
  AFE_Reg_Write (0x05, 0x0001F4);//5h
  AFE_Reg_Write (0x06, 0x00031E);//6h
  AFE_Reg_Write (0x07, 0x000384);//7h
  AFE_Reg_Write (0x08, 0x0004AE);//8h
  AFE_Reg_Write (0x09, 0x000000);//9h
  AFE_Reg_Write (10, 0x00018E);//Ah
  AFE_Reg_Write (11, 0x000514);//Bh
  AFE_Reg_Write (12, 0x00063E);//Ch
  AFE_Reg_Write (13, 0x001200);//Dh 15E8 chNGED  9-2-2020
  AFE_Reg_Write (14, 0x0017B3);//Eh
  AFE_Reg_Write (15, 0x0017BD);//Fh 17BD chNGED  9-2-2020
  AFE_Reg_Write (16, 0x001D70);//10h
  AFE_Reg_Write (17, 0x001D7A);//11h1992
  AFE_Reg_Write (18, 0x00232D);//12h
  AFE_Reg_Write (19, 0x002337);//13h1B68
  AFE_Reg_Write (20, 0x0028EA);//14h
  AFE_Reg_Write (21, 0x0011F8);//15h15E0
  AFE_Reg_Write (22, 0x0011FE);//16h15E6
  AFE_Reg_Write (23, 0x0017B5);//17h17B5
  AFE_Reg_Write (24, 0x0017BB);//18h17BB
  AFE_Reg_Write (25, 0x001D72);//19h198A
  AFE_Reg_Write (26, 0x001D78);//1Ah1990
  AFE_Reg_Write (27, 0x00232F);//1Bh1B60
  AFE_Reg_Write (28, 0x002335);//1Ch1B66
  AFE_Reg_Write (29, 0x009C3F);//1Dh
  //################################## configuiration reg
  AFE_Reg_Write (30, 0x000103);//1E //0000//160 milisec//103 10101/02
  AFE_Reg_Write (32, 0x008002);//20h//8006
  AFE_Reg_Write (33, 0x000002);//21h 
  AFE_Reg_Write (34, 0x005142);//22h Led A28A//4104 //104//5142
  AFE_Reg_Write (35, 0x000200);//23h
  AFE_Reg_Write (41, 0x000200);//29h
  //##################################
  AFE_Reg_Write (49, 0x000000);//31h
  AFE_Reg_Write (50, 0x0020B7);//32h1DFB
  AFE_Reg_Write (51, 0x00991F);//33h

  AFE_Reg_Write (52, 0x000000);//34h
  AFE_Reg_Write (53, 0x000000);//35h
  AFE_Reg_Write (54, 0x000000);//36h// 000Two LED mode 36//190 09/02/2020
  AFE_Reg_Write (55, 0x00031E);//37h0000
  AFE_Reg_Write (57, 0x000000);//39h
  AFE_Reg_Write (58, 0x000000);//3Ah
  //24 decimation mode on
  AFE_Reg_Write (61, 0x000000);//3Dh 24
}

void Reset_all_Reg__to_zero(){
int k;
Serial.println("Restting All registers");
for(k=0;k<=61;k++)
AFE_Reg_Write (k, 0x000000);
delay(1000);
}