AFE4404: AFE4404, I2C

Nishi

Part Number: AFE4404

I have some questions regarding AFE4404.
I am using it with ESP32 on Arduino IDE and SFH7072
I have write a code wrt these sensor but don't understand how to correctly deal with the register setting.
Need help on that.
Thank you,

Regards,
Nishikant

over 5 years ago

0 Nishi over 5 years ago

Intellectual 375 points

#include<stdio.h>
#include<stdlib.h>
#include<Wire.h>
const int Resetz = 15;
const int ADC_RDY = 4;
#define HRM_ADD 0x58
#define adc_step_size 0.0000057220458984
#define MAX 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
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 <= 20)
{
//Serial.print("0x2A :");
adc_ = AFE_Reg_Read(0x2A);
adc_ *= adc_step_size;
adc_ *= 0.1;
//Serial.print(adc_, HEX);
arr_0x2A[count] = adc_;
// Serial.println("\n");
//Serial.print("0x2B :");
adc_ = AFE_Reg_Read(0x2B);
adc_ *= adc_step_size;
adc_ *= 0.1;
//Serial.print(adc_, HEX);
arr_0x2B[count] = adc_;
// Serial.println("\n");
// Serial.print("0x2C :");
adc_ = AFE_Reg_Read(0x2C);
adc_ *= adc_step_size;
adc_ *= 0.1;
// Serial.print(adc_, HEX);
arr_0x2C[count] = adc_;
// Serial.println("\n");
// Serial.print("0x2D :");
adc_ = AFE_Reg_Read(0x2D);
adc_ *= adc_step_size;
adc_ *= 0.1;
// Serial.print(adc_, HEX);
arr_0x2D[count] = adc_;
// Serial.println("\n");
// Serial.print("0x2E :");
adc_ = AFE_Reg_Read(0x2E);
adc_ *= adc_step_size;
adc_ *= 0.1;
// Serial.print(adc_, HEX);
arr_0x2E[count] = adc_;
// Serial.println("\n");
// Serial.print("0x2F :");
adc_ = AFE_Reg_Read(0x2F);
adc_ *= adc_step_size;
adc_ *= 0.1;
// Serial.print(adc_, HEX);
arr_0x2F[count] = adc_;
// Serial.println("\n");
// Serial.print("0x40 :");
adc_ = AFE_Reg_Read(0x40);
adc_ *= adc_step_size;
adc_ *= 0.1;
// Serial.print(adc_, HEX);
arr_R_40[count] = adc_;
Serial.println("\n");
count++;
delay(40);
}
//AFE_Reg_Read(47);
AFE_Disable_Read ();
HRM_power_down(); //Powering down
Serial.println("#############");
for (int k = 0; k <= 20; 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(1000);
}
Serial.println("");
delay(1000000);
}
/****************************************
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[])
{
int trans_end = 0;
Wire.beginTransmission(HRM_ADD);
// Serial.println(reg_address);
Wire.write(reg_address);
// Serial.print(configData[0]);
// Wire.write(configData[0]);
// Serial.print(configData[1]);
// Wire.write(configData[1]);
// Serial.print(configData[2]);
// Wire.write(configData[2]);
Wire.write(configData, 3);
Wire.endTransmission();
delay(1);
// 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(200);
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("::convert it to a 22 bit value 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(1000);
return retVal;
}

char i2c_read(int reg_address, byte *read_Data) {
int trans_end = 0;
int byteCount = 3;
Wire.beginTransmission(0x58);
Wire.write(reg_address);
Wire.endTransmission();
Wire.requestFrom(0x58, 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() {

AFE_Reg_Write (01, 0x000064); //1h
AFE_Reg_Write (02, 0x00018E);
AFE_Reg_Write (03, 0x000320);
AFE_Reg_Write (04, 0x0004AE);
AFE_Reg_Write (05, 0x0001F4);
AFE_Reg_Write (06, 0x00031E);
AFE_Reg_Write (07, 0x000384);
AFE_Reg_Write (0x08, 0x0004AE);
AFE_Reg_Write (0x09, 0x000000);
AFE_Reg_Write (10, 0x00018E);
AFE_Reg_Write (11, 0x0000514);
AFE_Reg_Write (12, 0x00063E);
AFE_Reg_Write (13, 0x0015E8);
AFE_Reg_Write (14, 0x0017B3);
AFE_Reg_Write (15, 0x0017BD);
AFE_Reg_Write (16, 0x001988);
AFE_Reg_Write (17, 0x001992);
AFE_Reg_Write (18, 0x001B5E);
AFE_Reg_Write (19, 0x001B68);
AFE_Reg_Write (20, 0x001D33);
AFE_Reg_Write (21, 0x0015E0);
AFE_Reg_Write (22, 0x0015E6);
AFE_Reg_Write (23, 0x0017B5);
AFE_Reg_Write (24, 0x0017BB);
AFE_Reg_Write (25, 0x00198A);
AFE_Reg_Write (26, 0x001990);
AFE_Reg_Write (27, 0x001B60);
AFE_Reg_Write (28, 0x001B66);
AFE_Reg_Write (29, 0x009C3F);
AFE_Reg_Write (30, 0x000103); //1E //0000//160 milisec//103 101 01/02
AFE_Reg_Write (32, 0x008000);// 20h//8000
AFE_Reg_Write (33, 0x000003);//21h gain 1
/*1. First test : Set 22h register with 000A00 (RED LED)- In this case which LED is blinking/on
2. Second Test : Set 22h register with 000280 and re run the program- In this case which LED is blinking/on.
3. Third Test : Set 22h register with 00000A and re run the program- In this case which LED is blinking/on. */
AFE_Reg_Write (34, 0x000104); //22h Led A28A 104
AFE_Reg_Write (35, 0x000200);//23
AFE_Reg_Write (41, 0x000000);//29
AFE_Reg_Write (49, 0x000000);//31
AFE_Reg_Write (50, 0x001DFB);//32
AFE_Reg_Write (51, 0x00991F);//33
AFE_Reg_Write (52, 0x000000);//34
AFE_Reg_Write (53, 0x000000); //35
AFE_Reg_Write (54, 0x000000); //// Two LED mode 36
AFE_Reg_Write (55, 0x000000); //37
AFE_Reg_Write (57, 0x000000); //39
AFE_Reg_Write (58, 0x000000); //3A offset current
AFE_Reg_Write (61, 0x000020); ////20 decimation mode on

}

Can you review my code for settings are correct or do there is some missing things i need to correct??

0 Praveen Aroul over 5 years ago

TI__Mastermind 49956 points

Hello Nishikant,

Please make sure that you are able to get the SPI register write and read functioning correctly. It is not clear from your post if you are able to do that.

Once you are successful in establishing communication between the AFE and the MCU, then you can configure the AFE. You could check the datasheet (table 11 or 12) for the default register settings that you need to program the AFE with. Alternatively, you can also use the GUI in simulation mode to configure the AFE and export the register settings.

0 Nishi over 5 years ago in reply to Praveen Aroul

Intellectual 375 points

Hello Praveen,
Sorry for late reply, i configure correctly i also get some readings, Communication is done properly, i am able to change the LED current to.
please check this code, do the register values are correct ??

Fullscreen 0385.hrm.txt Download

#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);
}

###

Fullscreen HRM1.txt Download

#include<stdio.h>
#include<stdlib.h>
#include<Wire.h>
const int Resetz = 15;
const int ADC_RDY = 4;
#define HRM_ADD 0x58
#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();// setting all reg to zero
  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 (01, 0x000064);//1h
  AFE_Reg_Write (02, 0x00018E);//2h
  AFE_Reg_Write (03, 0x000320);//3h
  AFE_Reg_Write (04, 0x0004AE);//4h
  AFE_Reg_Write (05, 0x0001F4);//5h
  AFE_Reg_Write (06, 0x00031E);//6h
  AFE_Reg_Write (07, 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, 0x0015E8);//Dh
  AFE_Reg_Write (14, 0x0017B3);//Eh
  AFE_Reg_Write (15, 0x0017BD);//Fh
  AFE_Reg_Write (16, 0x001988);//10h
  AFE_Reg_Write (17, 0x001992);//11h
  AFE_Reg_Write (18, 0x001B5E);//12h
  AFE_Reg_Write (19, 0x001B68);//13h
  AFE_Reg_Write (20, 0x001D33);//14h
  AFE_Reg_Write (21, 0x0015E0);//15h
  AFE_Reg_Write (22, 0x0015E6);//16h
  AFE_Reg_Write (23, 0x0017B5);//17h
  AFE_Reg_Write (24, 0x0017BB);//18h
  AFE_Reg_Write (25, 0x00198A);//19h
  AFE_Reg_Write (26, 0x001990);//1Ah
  AFE_Reg_Write (27, 0x001B60);//1Bh
  AFE_Reg_Write (28, 0x001B66);//1Ch
  AFE_Reg_Write (29, 0x009C3F);//1Dh
  //################################## configuiration reg
  AFE_Reg_Write (30, 0x000103);//1E //0000//160 milisec//103 10101/02
  AFE_Reg_Write (32, 0x008000);//20h//8006
  AFE_Reg_Write (33, 0x000000);//21h
  AFE_Reg_Write (34, 0x005142);//22h Led A28A//4104 //104//5140
  AFE_Reg_Write (35, 0x000200);//23h
  AFE_Reg_Write (41, 0x000200);//29h
  //##################################
  AFE_Reg_Write (49, 0x000000);//31h
  AFE_Reg_Write (50, 0x001DFB);//32h
  AFE_Reg_Write (51, 0x00991F);//33h

  AFE_Reg_Write (52, 0x000000);//34h
  AFE_Reg_Write (53, 0x000000);//35h
  AFE_Reg_Write (54, 0x000000);//36h// Two LED mode 36
  AFE_Reg_Write (55, 0x000000);//37h
  AFE_Reg_Write (57, 0x000000);//39h
  AFE_Reg_Write (58, 0x000000);//3Ah
  //24 decimation mode on
  AFE_Reg_Write (61, 0x000024);//3Dh
}

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);
}

I got these reading wrt code

Ai2.txt

0 Nishi over 5 years ago in reply to Nishi

Intellectual 375 points

Hello Praveen Aroul,

Is this the correct way to write a register??

void AFE_Reg_Write(int reg_address, unsigned long  data1)// in data1 I send the 24bit data (0x00018E)
{
  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.write(configData, 3); //LSB
  Wire.endTransmission();
    delay(10);
  // Serial.println(" ");
  return (trans_end);
}

please correct me if I goes wrong.
Thank you

0 Praveen Aroul over 5 years ago in reply to Nishi

TI__Mastermind 49956 points

Nishi,

I checked your register settings and found a bug.

You have set conversion time to 115us. But number of averages is set to 4 (NUMAV of 3) and in this case, min. required ADC conversion time is 265us.

You may want to change NUMAV to 1.

I do not have the expertise on Arduino. Hence cannot comment on your code.

I suggest that you refer to the AFE4404EVM firmware source code available at the AFE4404EVM product folder (https://www.ti.com/product/AFE4404/technicaldocuments)

Data converters

Data converters forum

AFE4404: AFE4404, I2C