CS5463程序，有图有程序，大虾来看看，欢迎拍砖！

pengtao

#include<reg52.h>
#define uchar unsigned char
#define uint unsigned int
uchar flag,a;
uchar x;uchar y;uchar z;
uchar code  TAB[]="Voltage Current Power";
sbit SDO=P0^1;
sbit INT=P0^0;
sbit SCLK=P0^5;
sbit SDI=P0^3;
sbit CS=P0^4;
sbit RESET=P0^2;
void delay(uchar k)
{
uchar i,j;
for(i=0;i<k;i++)
for(j=0;j<100;j++)
        ;
}

void init_5463()
{                uchar n;
                RESET=1;
                delay(5);
                RESET=0;
                delay(5);
                RESET=1;
                SDI=0;
                SCLK=0;
                CS=0;
                delay(5);
                SDI=1;
                for(n=0;n<32;n++)
                {
                 SCLK=1;
                 delay(2);
                 SCLK=0;
                 delay(2);
                }
                SDI=0;
                delay(2);
                SCLK=1;
                delay(2);
                SCLK=0;
}
void write_5463(uchar com,uchar dat1,uchar dat2,uchar dat3)
{       
                uchar o,p,q,r;
                SCLK=0;
                                
            for(o = 0; o < 8; o++)  
                {
                 SDI=(bit)(com&0x80);   
                                           
                 SCLK=0;
                 delay(2);
                 SCLK=1;
                 delay(2);            
            com<<=1;  
            }

                for(p = 0; p < 8; p++)  
                {
                 SDI=(bit)(dat1&0x80);   
                                           
                 SCLK=0;
                 delay(2);
                 SCLK=1;
                 delay(2);              
            dat1<<=1;  
            }

                for(q = 0; q < 8; q++)  
                {
                 SDI=(bit)(dat2&0x80);   
                                           
                 SCLK=0;
                 delay(2);
                 SCLK=1;
                 delay(2);              
            dat2<<=1;  
            }

                for(r = 0; r < 8; r++)  
                {
                 SDI=(bit)(dat3&0x80);   
                                           
                 SCLK=0;
                 delay(2);
                 SCLK=1;
                 delay(2);              
            dat3<<=1;  
            }

}

uchar read_5463(uchar com1,uchar x,uchar y,uchar z)
{
                 uchar s,t,u,v,f=0xfe,g=0xfe,h=0xfe;
             SCLK=0;
                 for(s = 0; s < 8; s++)  
                {
                 SDI=(bit)(com1&0x80);   
                                           
                 SCLK=0;
                 delay(2);
                 SCLK=1;
                 delay(2);            
            com1<<=1;  
            }

           for(t = 0;t < 8; t++)  
                {
                 SDI=(bit)(f&0x80);   
                                           
                 SCLK=0;
                 delay(2);
                 SCLK=1;
                 delay(2);            
             f<<=1;
                 x<<=1;            
                 x|=(unsigned char)SDO;
                }
                return(x);

           for(u = 0;u < 8; u++)  
                {
                 SDI=(bit)(g&0x80);   
                                           
                 SCLK=0;
                 delay(2);
                 SCLK=1;
                 delay(2);            
             g<<=1;
                 y<<=1;            
                 y|=(unsigned char)SDO;
                }
                return(y);



           for(v = 0;v < 8; v++)  
                {
                 SDI=(bit)(h&0x80);   
                                           
                 SCLK=0;
                 delay(2);
                 SCLK=1;
                 delay(2);            
             h<<=1;
                 z<<=1;            
                 z|=(unsigned char)SDO;
                }
                return(z);


}



void com_init()
{
TMOD=0x20;
        TH1=0xfd;
        TL1=0xfd;
        SM0=0;
        SM1=1;
        TR1=1;
        REN=1;
        EA=1;
        ES=1;
}

void send(uchar m,uchar b)
{                 uchar l;

         if(flag==1)
                   {
                           ES=0;
                           flag=0;
                                 for(l=0;l<m;l++)
                                 {
                                SBUF=TAB[l];
                                while(!TI);
                                TI=0;
                                }
                                SBUF=b;
                                while(!TI);
                                TI=0;
                                SBUF=a;
                                while(!TI);
                                TI=0;

                                ES=1;
                   }
}


void main()
{  


while(1)
        {
   com_init();
   init_5463();
   write_5463(0x5e,0x80,0x00,0x00);
   write_5463(0x40,0x00,0x00,0x01);
   write_5463(0x4a,0x00,0x0f,0xa0);
   write_5463(0x74,0x00,0x00,0x00);
   write_5463(0x64,0x80,0x00,0x01);
   read_5463(0xe8,x,y,z);
   read_5463(0x10,x,y,z);
   send(22,z);
   send(22,y);
   send(22,z);
     
         }       
}
                 





void srei()interrupt 4
{
  RI=0;
  P1=SBUF;
  a=SBUF;
  flag=1;


}

pengtao

CS5463电路图 (原文件名:CS5463电路图.gif)

xl071310

CS5463 是一个测量电压电流的芯片 交流

heaven1983

请问电能如何计量？？你的程序只完成了初步的读写，电力参数的读写，电能计量以及芯片的标定，这些还是比较复杂，需要花很多的时间去做

pengtao

对的，还很初步，希望一起探讨，共同进步。

pengtao

#include<reg51.h>


#include"I2C.h"

#include<stdio.h>
//#include<c8051f040.h>
#include<intrins.h>
#include<math.h>
#include"struct.h"


#define zhilu 0

uchar code  TAB0[]="Voltage:";
uchar code  TAB1[]="Current:";
uchar code  TAB2[]="Power:";
/*sbit SDI0_5460 = P0^2;  //040输出，5460A输入
sbit SCK0_5460 = P0^1;  //支路号0
sbit SDO0_5460 = P0^0;  //040输入，5460A输出*/       

sbit SDI0_5460 = P0^3;
sbit SDO0_5460 = P0^1;
sbit SCK0_5460 = P0^5;
sbit CS_5460 = P0^4;
       

/***************************************全局变量定义**************************************/
unsigned char  rec_data[3] = {0};
unsigned char  send_data[3] = {0};



unsigned char VOLT_AC_OFF_CONFIG[4];
unsigned char VOLT_RMS[4],I_RMS[4],I_RMS_OFFSET[4];
unsigned char U_RMS_GAIN[4],I_RMS_OFFSET_1[4];
unsigned int flag1,time;                        //标志位flag,定时时间到标志time
unsigned int count1;
                 
unsigned char IIC_DATA;                        //24C16存储数据                                                                                                                                                                    
unsigned char add_II_count,add_UU_count,add_PW_count;
unsigned int PW_INT[3];

unsigned char UU_COUNT;
unsigned char UU_REC_COUNT;

unsigned int UU_RMS_SAVE;
unsigned char UU_MAX;
unsigned char UU_MIN;


unsigned int i;

unsigned int UU_RMS;
unsigned int II_RMS;
                                                                  
unsigned char PEAK;  //峰值系数

unsigned char status_data[3]={0};
unsigned int status_high8;

//unsigned char U_real[3],I_real[3],PW_real[3];

//unsigned char zhilu;//支路号
float PW_float;//功率值真实数据（浮点数）
float II_float;//电流值真实数据
float UU_float;//电压值真实数据
float PEAK_float;//峰值系数真实数据

unsigned char buf;
unsigned char tt;
bit time2;

void main()
{
       

          flag1 = 0;                  //定时变量
          time = 0;                   //定时变量                               
          IIC_DATA = 0;                //存储器变量

          add_II_count=0;        //存储电量的地址
          add_UU_count=0;
          add_PW_count=0;       
          count1 = 0;            //发送报文计数

                UU_COUNT=0;
                UU_REC_COUNT=0;
                status_high8=0;

//***************初始化接收和发送数组*********************//
        for(i=0;i<3;i++)          
        {
                rec_data = 0;
                send_data = 0;        
        }
                CS_5460=0;

                cs5460a_init();        //0支路初始化

//*****************************定时器1***********************************//
                 
        TMOD = 0x21;                         //工作方式1,8位定时器自动重装载         工作方式0,16位定时器
        TH1 = 0xFA;                                //波特率9600bit/s
        TL1 = 0xFA;

        TH0        = 0x3c;
        TL0        = 0xb0;

        SM0=0;        //串口在工作方式1
        SM1=1;       
        PCON=0x80;  //SMOD=1

        TR0=1;
        TR1 = 1;                                //定时器0允许
        REN=1;                                        //接收允许
               
        ET0 = 1;                                //允许定时器0中断

        EA = 1;
        ES=1;        //串口中断允许

        RI=0;
//        delay_ms(10);

/***初始化完毕后，电流、电压有效值需要空读一次**
        Wait_DRDY_High(zhilu);
        cs5460_READ(zhilu,0x16);
        Clear_DRDY(zhilu);
        Wait_DRDY_High(zhilu);
        cs5460_READ(zhilu,0x18);
        Clear_DRDY(zhilu);                    */

        //jiaozhun();        //CS5460A校准函数


        while(1)
        {                                       
                if(time2==1)
                {
                        time2 = 0;


//                        Wait_DRDY_High();                                     //等待电压转换完成
//                        cs5460_READ(0x18);                                 //上一周期电压有效值        //0 0 0 1 1 0 0 0   地址12
//                        inode[zhilu].UU[0] = rec_data[0];
//                        _delay_us(10);

                          ES=0;
                                SBUF=P0;
                                while(!TI);
                                TI = 0;
                                _delay_us(10);

                            SBUF=inode[zhilu].UU[0];
                          //SBUF=0x10;
                                while(!TI);
                                TI = 0;   
                                _delay_us(10);

                                SBUF=inode[zhilu].UU[1];
                          //SBUF=0x10;
                                while(!TI);
                                TI = 0;   
                                _delay_us(10);

                                SBUF=inode[zhilu].UU[2];
                          //SBUF=0x10;
                                while(!TI);
                                TI = 0;   
                                _delay_us(10);

                                _delay_us(100);

                                SBUF=inode[zhilu].II[0];
                                while(!TI);
                                TI = 0;
                                _delay_us(10);
                                SBUF=inode[zhilu].II[1];
                                while(!TI);
                                TI = 0;   
                                _delay_us(10);
                                SBUF=inode[zhilu].II[2];
                                while(!TI);
                                TI = 0;   
                                _delay_us(10);

                                _delay_us(100);

                                SBUF=inode[zhilu].PW[0];
                                while(!TI);
                                TI = 0;   
                                _delay_us(10);

                                SBUF=inode[zhilu].PW[1];
                                while(!TI);
                                TI = 0;   
                                _delay_us(10);
                                SBUF=inode[zhilu].PW[2];
                                while(!TI);
                                TI = 0;   
                                _delay_us(10);

                                ES=1;         //打开串口中断
                                _delay_us(10);

                        }                       
        }
}


/**********************************************************************
*CS5460A初始化函数
**********************************************************************/
void cs5460a_init()
{
        write_command(0xff);        //sys1
        write_command(0xff);        //sys1
        write_command(0xff);        //sys1
        write_command(0xfe);        //sys0       
/*************后续的*****************/
        cs5460_write(0x40);          //配置寄存器
        send_data[0] = 0x00; //增益为Gi=10
//    send_data[0] = 0x01; //增益为Gi=50
    send_data[1] = 0x00;   

//    send_data[2] = 0x61; //打开电流、电压滤波器,
        send_data[2] = 0xe1;//打开电流、电压滤波器
        //采样数据稳定关键：
        //        send_data[2] = 0x01;   //关闭电流、电压滤波器

       

/*        send_data[0] = 0xff;  //写数据3， 16~23位，高字节  
    send_data[1] = 0xff;  //写数据2， 8~f位，中低字节
    send_data[2] = 0xff;  //写数据1， 低0~7位，低字节*/                                                     
        cs5460_write(0x5e);          //清除状态寄存器

        send_data[0] = 0x00;   
    send_data[1] = 0x00;   
    send_data[2] = 0x00;      
        cs5460_write(0x74);                          //写中断屏蔽寄存器
        send_data[0] = 0x00;   
    send_data[1] = 0x00;   
    send_data[2] = 0x00;     
        cs5460_write(0x78);                          //写控制寄存器   
        send_data[0] = 0x00;   
    send_data[1] = 0x34;   
    send_data[2] = 0x9c;      
        cs5460_write(0x4c);                          //写EOUT 脉冲输出寄存器

        send_data[0] = 0x00;         
        send_data[1] = 0x0f;                            //计算周期为1s,得到N=4000
        send_data[2] = 0xa0;
                  
//    send_data[1] = 0x01;                    //每秒钟计算10次，即每秒钟采样10次，计算得到N=400
//   send_data[2] = 0x90;
       
        //此时读电能寄存器的值就是有功功率   
        cs5460_write(0x4A);                          //写CYCLE COUNT 寄存器
          
        _delay_us(10);
//        Wait_DRDY_High(n);
    cs5460_READ(0x1e);                    //读状态寄存器        
        send_data[0] = rec_data[0];   
    send_data[1] = rec_data[1];  
    send_data[2] = rec_data[2];               
        cs5460_write(0x5e);                          //写状态寄存器
        _delay_us(10);         
        write_command(0xe8);                          //启动CS5460A                  
}
/**********************************************************************
*CS5460A清状态寄存器最高位DRDY位
*********************************************************************
void Clear_DRDY(unsigned char n)
{                                                 
        send_data[0] = 0xff;  //写数据3， 16~23位，高字节  
    send_data[1] = 0xff;  //写数据2， 8~f位，中低字节
    send_data[2] = 0xff;  //写数据1， 低0~7位，低字节   
        cs5460_write(n,0x5e); //写指令，状态寄存器
} */
/**********************************************************************
*CS5460A等待状态寄存器最高位DRDY位置1，表明转换完毕
**********************************************************************/
void Wait_DRDY_High()
{  
    while(1)
    {  
        cs5460_READ(0x1e);                                     //读状态寄存器
        if( (rec_data[0]&0x80) != 0 ) break;  //判断DRDY位,转换结束就置位。
    }
}


                                                       

/*void jiaozhun(unsigned char n)
{
        Clear_DRDY();
        write_command(n,0xa0);  //发送POWER_HALT 命令       
        _delay_ms(1);

====================================================
第二阶段：校准交流增益寄存器。方法：将电压和电流输入加
至满幅，读取增益寄存器的值。
-----------------------------------------------------
        Clear_DRDY();
        write_command(0xce);          //写电流校准命令寄存器   
    _delay_ms(1);       
        Wait_DRDY_High();             //等待校准完成
        cs5460_READ(0x04);                 //******读电流增益寄存器*******
        _delay_ms(1);
        Clear_DRDY();
        write_command(0xd6);          //写电压校准命令寄存器   
    _delay_ms(1);       
        Wait_DRDY_High();             //等待校准完成
        cs5460_READ(0x08);                 //******读电压增益寄存器********
        _delay_ms(1);
        _delay_ms(1);       
    Clear_DRDY();
        write_command(n,0xcd);  //写电流校准命令寄存器   
   _delay_ms(10);       
        Wait_DRDY_High();     //等待校准完成
        cs5460_READ(n,0x20);    //读电流偏置寄存器
        _delay_ms(10);               
        Clear_DRDY();
        write_command(n,0xd5);  //写电压校准命令寄存器  
   _delay_ms(10);       
        Wait_DRDY_High();     //等待校准完成
        cs5460_READ(n,0x22);    //读电压偏置寄存器
        _delay_ms(10);
        _delay_ms(1);  
}  */

/**********************************************************************
*CS5460A写命令函数
**********************************************************************/
void write_command(unsigned char cs5460_command)
{

unsigned char data i;
for(i=0;i<8;i++)
{       
        SDI0_5460 = (bit)(cs5460_command&0x80);

//        SDI_5460 = (bit)(cs5460_command&0x80);
        _delay_us(1);
        SCK0_5460=0;
       
//        SCK_5460=1;       
        _delay_us(1);
    SCK0_5460=1;

//        SCK_5460=0;
        _delay_us(1);       
        cs5460_command = cs5460_command<<1;                       
}
}
/**********************************************************************
*CS5460A读函数
**********************************************************************/
void cs5460_READ(unsigned char cs5460_command)
{
        unsigned char data i,j;
        unsigned char temp;
        bit c_temp;
        write_command(cs5460_command);
        for(i=0;i<3;i++)
        {
                        temp = 0xfe;
                for(j=0;j<8;j++)
                {

                         SCK0_5460=0;
               
//                        SCK_5460=1;                                //时钟拉低
                        _delay_us(1);
/************下面三行必须要有，否则写入和读出的数据不正确***************/
                        SDI0_5460 = (bit)(temp&0x80);
                               
//                        SDI_5460 = (bit)(temp&0x80);
                         c_temp = SDO0_5460;
       
//                        c_temp = SDO_5460;                //cs5460a输出数据，040接收数据                       
                        rec_data = rec_data|c_temp;
                       
                        if(j!=7)
                        {
                                rec_data = rec_data<<1;
                                temp = temp<<1;                       
                        }
                       
                        SCK0_5460=1;

//                        SCK_5460=0;                                //时钟拉高
                        _delay_us(2);
                }       
        }
}
/**********************************************************************
*CS5460A写数据函数
**********************************************************************/
void cs5460_write(unsigned char cs5460_command)
{
        unsigned char data i,j;
        write_command(cs5460_command);
        for(i=0;i<3;i++)
        {
                for(j=0;j<8;j++)
                {
                       
                        SDI0_5460 = (bit)(send_data&0x80);
                        _delay_us(1);
//                        SDI_5460 = (bit)(send_data&0x80);
                        SCK0_5460=0;

//                        SCK_5460=1;         //时钟拉低
                        _delay_us(1);
                        SCK0_5460=1;
       
//                        SCK_5460=0;         //时钟拉高
                        _delay_us(1);                       
                        if(j!=7)
                                send_data = send_data<<1;
                       
                }
        }
}
/**********************************************************************
*电流有效值采集函数
*********************************************************************
unsigned int get_IRMS(unsigned char cs5460_command)
{
        unsigned char buf_I[3];
        unsigned char j;
        float IRMS;
        unsigned int II_RMS_INT;
        float G=1.0/2.0,temp=0.0;
        Wait_DRDY_High();
        cs5460_READ(cs5460_command);
        buf_I[0] = rec_data[0];
        buf_I[1] = rec_data[1];
        buf_I[2] = rec_data[2];
       
        Write_DRDY_LOW();
        for(j=0;j<8;j++)
        {
                if(buf_I[0]&0x80)
                temp+=G;
                G=G/2.0;
                buf_I[0]<<=1;
        }

        IRMS = 0.0464*((float)buf_I[0])-0.0114;
        II_RMS_INT=(unsigned int)(IRMS*1000.0);
//        IRMS = 11.9402*temp+0.0586;       
        return(II_RMS_INT);                               
} */
/***************************************************************
*电压有效值采集函数
**************************************************************
float get_VRMS(unsigned char cs5460_command)
{
        unsigned char buf_U[3];
        unsigned char j;
        float VRMS;
        float G=1.0/2.0,temp=0.0;
        Wait_DRDY_High();
        cs5460_READ(cs5460_command);
        buf_U[0] = rec_data[0];
        buf_U[1] = rec_data[1];
        buf_U[2] = rec_data[2];
        for(j=0;j<8;j++)
        {
                if(buf_U[0]&0x80)
                temp+=G;
                G=G/2.0;
                buf_U[0]<<=1;
        }
       
        //VRMS = 536.59*temp+1.50;
        VRMS = (22.831*temp-1.206)*44.0;
        return(VRMS);  
} */
/***************************************************************
*有功功率采集函数
**************************************************************
float get_PW(unsigned char cs5460_command)
{
        unsigned char buf_PW[3];
        unsigned char j;
        float PW;
        float G=1.0/2.0,temp=0.0;
        Wait_DRDY_High();
        cs5460_READ(cs5460_command);
        buf_PW[0] = rec_data[0]&0x7f;
        buf_PW[1] = rec_data[1];
        buf_PW[2] = rec_data[2];
        for(j=0;j<8;j++)
        {
                if(buf_PW[0]&0x80)
                temp+=G;
                G=G/2.0;
                buf_PW[0]<<=1;
        }
        PW = 10350.0*temp+70.1383;
        return(PW);        
}  */


/***************************************************
*        定时器中断
****************************************************/
void timer1() interrupt 1
{
        TH0        = 0x3c;
        TL0        = 0xb0;
        tt++;
        if(tt==0x14)
        {
                tt=0;
               

                Wait_DRDY_High();                                     //等待电压转换完成
                cs5460_READ(0x18);                                 //上一周期电压有效值        //0 0 0 1 1 0 0 0   地址12
                inode[zhilu].UU[0] = rec_data[0];       
                inode[zhilu].UU[1] = rec_data[1];
                inode[zhilu].UU[2] = rec_data[2];  

               
                Wait_DRDY_High();                                     //等待电流转换完成
                cs5460_READ(0x16);
                inode[zhilu].II[0] = rec_data[0];
                inode[zhilu].II[1] = rec_data[1];
                inode[zhilu].II[2] = rec_data[2];

                Wait_DRDY_High();                                     //等待能量转换完成
                cs5460_READ(0x14);                                     //上一周期能量值                 //0 0 0 1 0 1 0 0    地址10
                if((rec_data[0]&0x80)==0x80)                    //如果电能的最高位为1，则值是负数，需要对数据进行补码处理
                {                               
                        inode[zhilu].PW[0] = (~rec_data[0]);        //数据进行补码处理,负数的补码是反码加1
                        inode[zhilu].PW[1] = (~rec_data[1]);
                        inode[zhilu].PW[2] = (~rec_data[2])+0x01;
                        if(((inode[zhilu].PW[2]&0xff)==0x00)&&(inode[zhilu].PW[1]==0xff))//加1超限了
                        {                                                                       
                                inode[zhilu].PW[1] =0x00;
                                inode[zhilu].PW[0]=inode[zhilu].PW[0]+0x01;               
                        }                       
                }
                else
                {
                        inode[zhilu].PW[0] = rec_data[0];                                       
                        inode[zhilu].PW[1] = rec_data[1];
                        inode[zhilu].PW[2] = rec_data[2];       
                }

                time2=1;
       
        }



}
/******************************************************************************
*串口中断，中断号4
*******************************************************************************/
void timer0() interrupt 4
{       
//定时器计数50000溢出一次
               
        UU_COUNT++;         //定时计数
       
        RI=0;
        buf=SBUF;



/****************************************************************************************
*                                计数23，计时大约50ms
***************************************************

                if(UU_COUNT==0x2d)        //计数45,大约100ms
                {
                        UU_COUNT=0;
       
                        UU_REC_COUNT++;//接收计数
                }       
/****************************************************************************************
*        计时2S时间到 将20组采集的电压有效值数据中去掉最大和最小值，剩下的取平均值
***************************************************************************************         
                if(UU_REC_COUNT==0x0a) //10          计时1s
                {                       
                        UU_REC_COUNT=0;       

                                Wait_DRDY_High();                                     //等待电压转换完成
                                cs5460_READ(0x18);                                 //上一周期电压有效值        //0 0 0 1 1 0 0 0   地址12
                                inode[zhilu].UU[0] = rec_data[0];       
                                inode[zhilu].UU[1] = rec_data[1];
                                inode[zhilu].UU[2] = rec_data[2];


                                Wait_DRDY_High();                                     //等待电流转换完成
                                cs5460_READ(0x16);
                                inode[zhilu].II[0] = rec_data[0];
                                inode[zhilu].II[1] = rec_data[1];
                                inode[zhilu].II[2] = rec_data[2];
                       

       
        /****************************************************************************************
        *                        电能采集，有功功率
        ****************************************************************************************       
                                               
                                Wait_DRDY_High();                                     //等待能量转换完成
                                cs5460_READ(0x14);                                 //上一周期能量值                 //0 0 0 1 0 1 0 0    地址10
                                if((rec_data[0]&0x80)==0x80)                    //如果电能的最高位为1，则值是负数，需要对数据进行补码处理
                                {                               
                                        inode[zhilu].PW[0] = (~rec_data[0]);        //数据进行补码处理,负数的补码是反码加1
                                        inode[zhilu].PW[1] = (~rec_data[1]);
                                        inode[zhilu].PW[2] = (~rec_data[2])+0x01;
                                        if(((inode[zhilu].PW[2]&0xff)==0x00)&&(inode[zhilu].PW[1]==0xff))//加1超限了
                                        {                                                                       
                                                inode[zhilu].PW[1] =0x00;
                                                inode[zhilu].PW[0]=inode[zhilu].PW[0]+0x01;               
                                        }                       
                                }
                                else
                                {
                                        inode[zhilu].PW[0] = rec_data[0];                                       
                                        inode[zhilu].PW[1] = rec_data[1];
                                        inode[zhilu].PW[2] = rec_data[2];       
                                }
           } */
        time=1;
               
}

pengtao

CS5463原版数据手册不要看中文版最易被误导ourdev_628730A3YGPK.rar(文件大小:559K) (原文件名:CS5463原版数据手册不要看中文版最易被误导.rar)

hddgf

记号 芯片功能寄存器比较多，难理解。

136420962

电路图有没有完整的参数...
调理电路不太懂..LZ能否解释下....
thx

pengtao

show 下我是怎么读取电压的！ (原文件名:读取电压OK.JPG)

pengtao

悬赏求助（有程序赠送），有哪位能回答：CS5463为什么要校准（根本原因）？？？

pengtao

赠送CS5463最新程序ourdev_632101LY4KLC.rar(文件大小:25K) (原文件名:CS5463程序成功.rar)

pengtao

O(∩_∩)O哈！我终于领悟为什么要校正了————校正的意思就是让我们得到的3字节的16进制数据在满量程的0.6附近，不要太大或太小，会有较大误差！

pengtao

想学STM32了，想求购个学习板和仿真器。

qdshen

校准就是为了调整批量使用时电压、电流传感器的采样偏差

pengtao

show 下我用VB写的上位机软件，要感谢our dev 的网友小梅（参考了他的视频教程）仅用一天完成。

CS5463数据采集上位机 (原文件名:ccccccccccc.jpg)

pengtao

想要程序的，赶紧跟帖哦！！

sdtean

发上来看看吧，学习一下！

strange

mark

edaworld

马克

Bicycle

走进来了

sdmcu51

mark

wps_90

我用CS5460a为何我每次读
#define ESFR      0x14        //能量累计寄存器
#define IRMSSFR        0x16        //电流有效值寄存器
#define VRMSSFR        0x18        //电压有效值寄存器
最低8位的数值都变化非常大,我把输入都对地短路了,就是找不到原因

wps_90

uchar xdata send_data[3];          //存放3个字节数据，高字节在前


void CS5460_ReadReg(uchar Address)
{
        uchar i=0,j,temp;
        CS5460_Write(Address);                  //写命令字选取寄存器
        while(i<3)
        {
                send_data = 0;
                temp = 0xFE;
                j=8;
                while(j--)
                {
                        MOSI=((bit)(temp & 0x80));                //发送SYS0               
                        SCK=1;
                        temp <<= 1;                                                                                               
                        send_data <<= 1;       
                        send_data |= MISO;                //读出时高位在前
                        SCK=0;                        
                }
                i++;
        }
}

void CS5460_Write(uchar Command)   //写命令
{
        uchar i=8;
        SCK=0;
        while(i--)
        {
        //        MOSI=((Command & 0x80)==0?0:1);
                 MOSI=(bit)(Command & 0x80);          //最高位送入SDI
                SCK=1;                                                                  //上升沿写入
                SCK=0;;
                Command <<= 1;
        }
}

guyantongxin

回复【25楼】wps_90
-----------------------------------------------------------------------

请问在读数据的时候不是还需要给SDI口写0xfe嘛？

jxmykl

我也在使用cs5460a，不过我是用51编的，程序中遇到很多问题， 希望大家能交流一下~~~

xsy666

回复【5楼】pengtao
-----------------------------------------------------------------------
运行了，怎有一个错误，是：TEXT1.C(15): error C129: missing ';' before 'code'
错误在这个地方。
uchar code  TAB0[]="Voltage:";
uchar code  TAB1[]="Current:";
uchar code  TAB2[]="Power:";

xsy666

欢迎交流

xsy666

回复【4楼】pengtao
-----------------------------------------------------------------------

请问你的这个程序对吗？

guyantongxin

回复【5楼】pengtao
-----------------------------------------------------------------------

请问LZ，功率采集函数中  PW = 10350.0*temp+70.1383;   这个表达式是怎么确定的，谢谢！

yanrz

先标注下，以后要用，哈哈！

feixue

MARK一下

pengtao

悬赏的程序可用的！

wdmfhvk

http://www.taobao.com/上有现成可用的方案，省时省力

sl961102

好东西，

jujishou_0

回复【楼主位】pengtao
-----------------------------------------------------------------------

楼主研究的如何了，我也正在用cs5463，能给个邮箱号吗，有事请教一下

yanrz

呵呵，不错，现在想重启多年前的项目，希望大家一起研究！

pengtao

欢迎交流，QQ2535919581

locky_z

mark

jijy2100

我也正在使用CS5403芯片开发一款无功补偿的产品,一起交流一下,

kingboy100

mark

bingshuihuo888

学习了！

cyuyansheji

回复【12楼】pengtao
-----------------------------------------------------------------------

我也在做功率补偿这部分，那个补偿的意思不是很明白 ，你能给我讲讲吗？？

dave

菜鸟来了，正在用cs5463做一个电表。
目前的问题是，不知道如何将读出的16进制功率值转换成实际的功率值。
另一个是如果进行校正的。

有知道的XD请赐教!

hyf20462046

菜鸟提问
PW = 10350.0*temp+70.1383;
VRMS = (22.831*temp-1.206)*44.0;
II_RMS_INT=(unsigned int)(IRMS*1000.0);
上面几行中10350.0，70.1383   22.831......是什么数据

tonghe

正需要！LZ能否发一份资料69383181@qq.com,谢谢！

liao_yan_si

咱们现在也在做这一块，问下，这个东西如何校准的啊！我做的为啥校准电流的时候 AC增益寄存器的值一直是0x040000啊？？？？

johnny_zi

最近在搞这个

xxiangj

最近也要做这个.三相4线的的测量.没有头绪啊!望知道的多多指点!

ds168

gandiadia

楼主，请问你这是做的三相计量？

chump

liao_yan_si 发表于 2012-6-20 13:51
咱们现在也在做这一块，问下，这个东西如何校准的啊！我做的为啥校准电流的时候 AC增益寄存器的值一直是0x0 ...

能告诉我为什么吗？》 我也一样

wangyeqing333

楼主的原理图中有几个电阻和电容的参数没有标，能否给共享一个带具体参数的原理图呢~，谢谢

jeoo8888

也想玩一下这个下载来看一下

friendly

正准备玩CS5463,学习了，谢谢

htbst

都做好了吗？谢谢！！！！！！！！！1

fengnaf

我的脚步将走遍大江南北。。。。。新疆乌鲁木齐----布丁酒店

fengnaf

这程序能执行完？return（y）可以执行到？

wangle315065

mark一下，最近再用5490

落草火子

正在使用