[SOLVED] 24 bit ADC not working with P89V51RD2

Hi, All.

Am trying to interface CS5460 and P89V51rd2.
The Set up is not working please suggest me wher i gone wrong.

Am using 4 seven segment display, am getting some garbage values in the display I wanted to display consumed power/energy, even i have tried voltage and current.


Please guide me what is wrong with my code.

Below is my c code

#include <reg51.H>



//**************Display Functions********************************************************************************************
void display_data(unsigned int data_N_display);
void delay(unsigned int itime);

unsigned int c=0,x=0; //initialize key counter and key flag

unsigned char array[]= {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x06f};
unsigned char dig_ctl[] = {0x01,0x02,0x04,0x08} ;

unsigned char digit[4];

//unsigned long count = 0,flag =0, flag1=0,flag2 = 0,flag3 = 0,flag4=0,flag5 = 0,flag6 = 0,flag7=0,flag8 = 0,flag9 = 0,flag10 = 0;

unsigned char dig_num;
//bit flag;
//******************************************************************************************************************************



void timer0(void) interrupt 1 // timer o only for display;;

{
// P0 = 0xFF;

P2 = 0x00;

P0 = digit[dig_num];
P2 = dig_ctl[dig_num];

dig_num++;

if(dig_num >=4)
dig_num = 0;

}
//*******************************************************************************************************************************

void display_data(unsigned int data_N_display)
{
unsigned char temp_data;
unsigned char index;
unsigned long quotient;
unsigned char temp_digit[5];

for(index=0;index<4;index++)
{
quotient = data_N_display/10;
temp_data = data_N_display-quotient * 10;
temp_digit[index] = temp_data;
data_N_display = quotient;
}
for(index = 0;index<4;index++)
{
digit[index] = array[temp_digit[index]];

}
}
//=============================================================================================================================================
unsigned char ch;
long COUNT, tlong;

//************************************************************************************

//////////////////CS5460A_NEW.c////////////////////////
sbit CS5460ADout = P1^0;//at RC1_bit; // INPUT PIN
sbit CS5460AClk = P1^1; // at RC0_bit; // OUTPUT PIN
sbit CS5460ADin = P1^2;//at RD0_bit; // OUTPUT PIN

//*************************************************************
//CS5460A register addresses
//*************************************************************
#define CS5460A_REG_CONFIG 0x00
#define CS5460A_REG_AIN1_OFFSET 0x02
#define CS5460A_REG_AIN1_GAIN 0x04
#define CS5460A_REG_AIN2_OFFSET 0x06
#define CS5460A_REG_AIN2_GAIN 0x08
#define CS5460A_REG_CYCLE 0x0A
#define CS5460A_REG_PULSE 0x0C
#define CS5460A_REG_CURRENT 0x0E
#define CS5460A_REG_VOLT 0x12
#define CS5460A_REG_POWER 0x14
#define CS5460A_REG_ENERGY 0x16
#define CS5460A_REG_IRMS 0x18
#define CS5460A_REG_VRMS 0x1A
#define CS5460A_REG_TBC 0x1C
#define CS5460A_REG_PWR_OFFSET 0x1E
#define CS5460A_REG_STATUS 0x20
#define CS5460A_REG_IACOFFSET 0x22
#define CS5460A_REG_VACOFFSET 0x24
#define CS5460A_REG_MASK 0x34
#define CS5460A_REG_CONTROL 0x38
//*************************************************************
//CS5460A commands
//*************************************************************
#define CONVERT_CONTINOUS 0xE8
#define CONVERT_ONCE 0xE0
#define CS5460A_SYNC0 0xFE
#define CS5460A_SYNC1 0xFF
#define POWER_UP_HALT 0xA0
#define CAL_AIN1_DC_GAIN 0xCA
#define CAL_AIN1_DC_OFFSET 0xC9
#define CAL_AIN2_DC_GAIN 0xD2
#define CAL_AIN2_DC_OFFSET 0xD1
#define CS5460A_WRITE 0x40
#define CS5460A_READ 0x3E
//*************************************************************
//config data
//*************************************************************
#define CLOCK_DIVIDER 0x00000004
#define AIN1_GAIN_10 0x00000000
#define AIN1_GAIN_50 0x00010000
#define SOFT_RESET 0x00000080
#define MASK_NO_INTERRUPTS 0x00000000
#define STATUS_CLR_CRDY 0x00100000
#define STATUS_CLR_DRDY 0x00800000
#define STATUS_CLR_ALL 0x00FFFFFF
#define CONTROL_DEFAULT 0x00000000
#define CURRENT_GAIN_DEFAULT 0x00100000
#define VOLT_GAIN_DEFAULT 0x00100000
#define COMPUTATION_CYCLE 0x00000FA0
#define TIME_BASE 0x00800000
extern long CS5460ARead24Bits(char AdcRegisterAddress);
extern void CS5460AWriteCommand(char Command);
extern void CS5460AReset(void);
extern void CS5460AWrite24Bits(long RegisterData, char AdcRegisterAddress);
extern void CS5460AReset(void);
extern void CS5460APulseClock(void);
void Delay_ms(unsigned int itime);
void Bcd2Dec(unsigned short bcdnum) ;

unsigned long Va, Gain, Test, Volt ,energy;
//===========================================================================

//===========================================================================
char CS5460AReadDRDYBit(void)
{
char ReadyBit;
long StatusRegister;
StatusRegister=CS5460ARead24Bits(CS5460A_REG_STATUS);
if(StatusRegister & 0x00800000){ReadyBit=1;}else{ReadyBit=0;}//get DRDY bit
return(ReadyBit);
}

//===========================================================================
char CS5460AReadCRDYBit(void)
{
char ReadyBit;
long StatusRegister;
StatusRegister=CS5460ARead24Bits(CS5460A_REG_STATUS);
if(StatusRegister & 0x00100000){ReadyBit=1;}else{ReadyBit=0;}//get CRDY bit
return(ReadyBit);
}
//===========================================================================

void CS5460AResetConfigure(void)
{
CS5460AReset();
CS5460AWrite24Bits((CLOCK_DIVIDER |AIN1_GAIN_10),CS5460A_REG_CONFIG);//Ain1
CS5460AWrite24Bits(CONTROL_DEFAULT,CS5460A_REG_CONTROL);//write default
CS5460AWrite24Bits(STATUS_CLR_ALL,CS5460A_REG_STATUS);//clear all status
CS5460AWrite24Bits(MASK_NO_INTERRUPTS,CS5460A_REG_MASK);//no interrupts
//gain is 10, clock divider is 4
CS5460AWrite24Bits(CURRENT_GAIN_DEFAULT,CS5460A_REG_AIN1_GAIN);//Ain1 gain
CS5460AWrite24Bits(VOLT_GAIN_DEFAULT,CS5460A_REG_AIN2_GAIN);//Ain2 gain
CS5460AWrite24Bits(COMPUTATION_CYCLE,CS5460A_REG_CYCLE);//rms cycle
CS5460AWrite24Bits(TIME_BASE,CS5460A_REG_TBC);//default time base
CS5460AWriteCommand(CONVERT_CONTINOUS);//start conversions
return;
}
//===========================================================================
void CS5460AReset(void)
{
char BitCounter;
//Cirrus Logic data sheet page 43
for(BitCounter=0;BitCounter<3;BitCounter++)//send 3 SYNC1 bytes
{
CS5460AWriteCommand(CS5460A_SYNC1);
}
CS5460AWriteCommand(CS5460A_SYNC0);//send 1 SYNC0 byte
CS5460AWrite24Bits(SOFT_RESET,CS5460A_REG_CONFIG);//issue soft reset
}

//===========================================================================
void CS5460AWriteCommand(char Command)
{
char WriteByte;
char BitCounter;
WriteByte=Command;
for(BitCounter=0;BitCounter<8;BitCounter++)
{
if(WriteByte & 0x80){CS5460ADin=1;}else{CS5460ADin=0;}
CS5460APulseClock();
WriteByte=WriteByte<<1;
}
}
//===========================================================================
void CS5460AWrite24Bits(long RegisterData, char AdcRegisterAddress)
{
char BitCounter;
char WriteByte;
long WriteLong;
WriteLong=RegisterData;
WriteByte=(CS5460A_WRITE | AdcRegisterAddress);//write command with reg address
for(BitCounter=0;BitCounter<8;BitCounter++)//send command
{
if(WriteByte & 0x80){CS5460ADin=1;}else{CS5460ADin=0;}
CS5460APulseClock();
WriteByte=WriteByte<<1;
}
for(BitCounter=0;BitCounter<24;BitCounter++)//write 24 bits
{
if(WriteLong & 0x00800000){CS5460ADin=1;}else{CS5460ADin=0;}
CS5460APulseClock();
WriteLong=WriteLong<<1;
}
return;
}
//===========================================================================
long CS5460ARead24Bits(char AdcRegisterAddress)
{
char BitCounter=0;
//send read command with register address
long WriteByte;
long Data24Bits;
long ThreeSync0;
WriteByte=CS5460A_READ & AdcRegisterAddress;
Data24Bits=0;
ThreeSync0=0x00FEFEFE;
CS5460ADout=1;//pull up port pin for a read
for(BitCounter=0;BitCounter<8;BitCounter++)
{
if(WriteByte & 0x80){CS5460ADin=1;}else{CS5460ADin=0;}
CS5460APulseClock();
WriteByte=WriteByte<<1;
}
for(BitCounter=0;BitCounter<24;BitCounter++)//read 24 bits
{
if(ThreeSync0 & 0x00800000){CS5460ADin=1;}else{CS5460ADin=0;}//SYNC0 command on SDI
CS5460APulseClock();
ThreeSync0=ThreeSync0<<1;
if(CS5460ADout){Data24Bits=((Data24Bits<<1)| 0x1);}//get msb and other bits
else{Data24Bits=Data24Bits<<1;}
}
return(Data24Bits>>1 & 0x00FFFFFF);
}
//===========================================================================
void CS5460APulseClock(void)
{
CS5460AClk=1;
CS5460AClk=0;
}//===========================================================================


void Delay_ms(unsigned int itime)

{

unsigned int i,j;
for(i=0;i<itime;i++)
for(j=0;j<1257;j++) ;
}
//=============================================================================



/** Bcd2Dec**/ //convert and display routine

void Bcd2Dec(unsigned long bcdnum)
{
unsigned long tmp = 0;

tmp = (bcdnum >> 4) * 10;
tmp += (bcdnum & 0x0F);
//return tmp;
display_data(tmp);
}//

//============================================================================
void main(void)
{

IE=0x82; // enable ext int 0
IT0=1;
TMOD= 0x02; // timer 0
TH0=0x46; // for refresh led
TR0=1;

/* SCON = 0x50;
ET1 = 1;
TH1=0xef;
TL1=0xff;
TR1=1;
*/
P0=0x00;
P2 = 0x00;
dig_num = 0;
// count = 9999;
//flag = 0;
// display_data(volt1);

COUNT = 0;

CS5460AClk=0;
CS5460AResetConfigure();
Delay_ms(10);
if(CS5460AReadCRDYBit()){Va=1;}
Gain=CS5460ARead24Bits(CS5460A_REG_VOLT);//dummy read

//display_data(1234);

//===========================================================================
while(1)
{
if(CS5460AReadCRDYBit())
{
//CS5460AWrite24Bits(STATUS_CLR_DRDY,CS5460A_REG_STATUS);//clear DRDY
//Test=CS5460ARead24Bits(CS5460A_REG_IRMS);
Test=CS5460ARead24Bits(CS5460A_REG_CURRENT);
Volt=CS5460ARead24Bits(CS5460A_REG_VOLT);
energy = CS5460ARead24Bits(CS5460A_REG_POWER);
CS5460AWrite24Bits(STATUS_CLR_CRDY,CS5460A_REG_STATUS);//clear CRDY
}
//Conv_Display(Test);


//Bcd2Dec(Volt) ;
//Delay_ms(100);
Bcd2Dec(energy) ;//display_data(Volt);
Delay_ms(140);
Bcd2Dec(Volt) ;//display_data(Volt);
Delay_ms(140);





}//end of while
}//end of main