设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › cs56463-12864-STC89C52单片机驱动源代码
返回列表 发新帖
查看: 3803|回复: 6
打印 上一主题 下一主题
收起左侧

cs56463-12864-STC89C52单片机驱动源代码

[复制链接]
跳转到指定楼层
楼主
ID:334946 发表于 2018-5-21 16:07 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
这是单相电用电器监测装置的设计源代码
用cs5463进行电能计算 单片机控制 12864显示的源代码

单片机源码如下:
  1.                    //头文件
  2. #include <REG52.h>
  3. #include <string.h>
  4. #include <intrins.h>
  5. #define uint  unsigned int
  6. #define uchar unsigned char

  8. typedef bit  bool;
  9. typedef unsigned char  uint8;                   /* defined for unsigned 8-bits integer variable         无符号8位整型变量  */
  10. typedef signed   char  int8;                    /* defined for signed 8-bits integer variable                有符号8位整型变量  */
  11. typedef unsigned int   uint16;                  /* defined for unsigned 16-bits integer variable         无符号16位整型变量 */
  12. typedef signed   int   int16;                   /* defined for signed 16-bits integer variable                 有符号16位整型变量 */
  13. typedef unsigned long  uint32;                  /* defined for unsigned 32-bits integer variable         无符号32位整型变量 */
  14. typedef signed   long  int32;                   /* defined for signed 32-bits integer variable                 有符号32位整型变量 */
  15. typedef float          fp32;                    /* single precision floating point variable (32bits) 单精度浮点数（32位长度） */





  21. /*****************************************************************************/
  22. sbit LCM_cs   = P2^0;  //RS
  23. sbit LCM_std  = P2^1;  //SID
  24. sbit LCM_sclk = P2^2;  //SCLK
  25. sbit LCM_psb  = P2^3;   //H=并口; L=串口;
  26. sbit LCM_rst  = P2^4;   //Reset Signal 低电平有效        sbit LCM_rst  = P2^0;
  27. //sbit beep     = P2^5;
  28. //sbit p2_4     = P2^6;  //定义背光控制口
  29. char a,b,c;
  30. char aa,bb,cc,dd,ee;
  31. char i,q,T=125;
  32. uchar code tab1[]={
  33. "电压            "
  34. "功率            "
  35. "电流            "
  36. "温度            "
  37. };
  38. /****************************************************************************/

  40. uchar r[3]={0x00,0x00,0x00};

  42. /******************************************************************
  43.                            接口定义
  44. ******************************************************************/
  45. sbit SCLK=P1^1;         //ck
  46. sbit MOSI=P1^0;         //DI
  47. sbit MISO=P1^2;         //DO           //这个定义对吗？
  48. sbit INT=P3^2;
  49. sbit CS=P1^3;
  50. sbit RST=P1^4;        //RST

  52. #define CS5463_VScale       525             //计算电压比例,220V*250mv/110mv=500V
  53. #define CS5463_IScale       (250/10)        //计算电流比例

  55. static uint8 RX_Buff[4];                                        //CS5463读写缓冲区
  56. uint8 sta;                                                                        //芯片状态

  58. #define READ_MASK                0xBF        //读寄存器时的屏蔽码，与（写）地址相与
  59. #define CMD_SYNC0            0XFE          //结束串口重新初始化
  60. #define CMD_SYNC1            0XFF          //开始串口重新初始化
  61. #define REG_CONFR           0x40           //配置
  62. #define REG_CYCCONT         0x4A           //一个计算周期的A/D转换数
  63. #define REG_STATUSR         0x5E         //状态
  64. #define REG_MODER           0x64          //操作模式
  65. #define REG_MASKR           0x74          //中断屏蔽
  66. #define REG_CTRLR           0x78          //控制
  67. #define CMD_STARTC           0XE8          //执行连续计算周期

  69. #define REG_VRMSR           0X18          //VRMS
  70. #define REG_IRMSR           0X16          //IRMS
  71. #define REG_Pactive           0X14          //Pactive

  73.                   


  76. /*************************************************************
  77. ** 函数名称:uDelay
  78. ** 函数功能:延时
  79. ** 函数参数:j
  80. ** 返回值:无
  81. ** 创建时间:2009-4-23
  82. ** 第一次修改时间:无
  83. **************************************************************/
  84. static  void uDelay(uint8 j)

  86. {
  87.   uint8 i;
  88.   for(;j>0;j--)
  89.         { for(i=0;i<255;i--)
  90.                 {
  91.                 ;
  92.                 }
  93.         }
  94. }
  95. /*************************************************************
  96. ** 函数名称:CS5463CMD
  97. ** 函数功能:CS5463命令函数
  98. ** 函数参数:无
  99. ** 创建时间:2009-9-14
  100. ** 第一次修改时间:无
  101. **************************************************************/
  102. static void CS5463CMD(uint8 cmd)
  103. {
  104. uint8 i;
  105. SCLK = 1;
  106. CS = 0;
  107. i = 0;
  108. while(i<8)
  109. {
  110.           uDelay(50);
  111.         SCLK = 0;
  112.         if(cmd&0x80)MOSI = 1;
  113.         else                MOSI = 0;
  114.         uDelay(50);
  115.         SCLK = 1;                                         //在时钟上升沿，数据被写入CS5463
  116.         cmd <<= 1;
  117.         i++;
  118. }
  119. uDelay(50);
  120. CS = 1;
  121. }
  122. /*************************************************************
  123. ** 函数名称:CS5463WriteReg
  124. ** 函数功能:CS5463写寄存器函数
  125. ** 函数参数:无
  126. ** 创建时间:2009-9-14
  127. ** 第一次修改时间:无
  128. **************************************************************/
  129. void CS5463WriteReg(uint8 addr,uint8 *p)
  130. {
  131. uint8 i,j;
  132. uint8 dat;
  133. SCLK = 1;
  134. CS = 0;
  135. i = 0;
  136. while(i<8)
  137. {
  138.           uDelay(50);
  139.         SCLK = 0;
  140.         if(addr&0x80)MOSI = 1;
  141.         else                 MOSI = 0;
  142.         uDelay(50);
  143.         SCLK = 1;                                         //在时钟上升沿，数据被写入CS5463
  144.         addr <<= 1;
  145.         i++;
  146. }
  147. j = 0;
  148. while(j<3)
  149. {
  150.           dat = *(p+j);
  151.         i = 0;
  152.         while(i<8)
  153.         {
  154.                   uDelay(50);
  155.                 SCLK = 0;
  156.                 if(dat&0x80)MOSI = 1;
  157.                 else                MOSI = 0;
  158.                 uDelay(50);
  159.                 SCLK = 1;                                  //在时钟上升沿，数据被写入CS5463
  160.                 dat <<= 1;
  161.                 i++;
  162.         }
  163.         j++;
  164. }
  165. uDelay(50);
  166. CS = 1;
  167. }
  168. /*************************************************************
  169. ** 函数名称:CS5463ReadReg
  170. ** 函数功能:CS5463读寄存器函数
  171. ** 函数参数:无
  172. ** 创建时间:2009-9-14
  173. ** 第一次修改时间:无
  174. **************************************************************/
  175. void CS5463ReadReg(uint8 addr,uint8 *p)
  176. {
  177. uint8 i,j;
  178. uint8 dat;
  179. SCLK = 0;
  180. CS = 0;
  181. addr &= READ_MASK;
  182. i = 0;
  183. while(i<8)
  184. {
  185.           uDelay(50);
  186.         SCLK = 0;
  187.         if(addr&0x80)MOSI = 1;
  188.         else                 MOSI = 0;
  189.         uDelay(50);
  190.         SCLK = 1;
  191.         addr <<= 1;                                         //在时钟上升沿，数据被写入CS5463
  192.         i++;
  193. }
  194. uDelay(50);
  195. MOSI = 1;
  196. j = 0;
  197. while(j<3)
  198. {
  199.         i = 0;
  200.         dat = 0;
  201.         while(i<8)
  202.         {
  203.                 if(i==7)MOSI = 0;
  204.                 else        MOSI = 1;
  205.                 SCLK = 0;
  206.                 uDelay(50);
  207.                 dat <<= 1;                                                
  208.                 if(MISO)dat |= 0x01;
  209.                 else        dat &= 0xFE;
  210.                 SCLK = 1;
  211.                 uDelay(50);                                                         
  212.                 i++;
  213.         }
  214.         *(p+j) = dat;
  215.         j++;
  216. }
  217. MOSI = 1;
  218. CS = 1;
  219. }
  220. /*************************************************************************************************
  221. ** CS5463 应用函数
  222. *************************************************************************************************/
  223. /*************************************************************
  224. ** 函数名称:CS5463Init
  225. ** 函数功能:CS5463复位和初始化函数
  226. ** 函数参数:无
  227. ** 创建时间:2009-9-14
  228. ** 第一次修改时间:无
  229. **************************************************************/
  230. bit CS5463_Init(void)           //bit 可以这样吗？
  231. {
  232. RST = 0;
  233. uDelay(200);
  234. RST = 1;
  235. uDelay(100);
  236. //----------------------
  237. //发送同步序列
  238. RX_Buff[0] = CMD_SYNC1;
  239. RX_Buff[1] = CMD_SYNC1;
  240. RX_Buff[2] = CMD_SYNC0;
  241. CS5463WriteReg(CMD_SYNC1,RX_Buff);          //#define CMD_SYNC1            0XFF          //开始串口重新初始化               
  242. //----------------------
  243. //初始化--配置寄存器
  244. //相位补偿为PC[6:0]=[0000000]；
  245. //电流通道增益为Igain=10；
  246. //EWA=0;
  247. //INT中断为低电平有效IMODE:IINV=[00]
  248. //iCPU=0
  249. //K[3:0]=[0001]
  250. RX_Buff[0] = 0x00;                                                
  251. RX_Buff[1] = 0x00;
  252. RX_Buff[2] = 0x01;
  253. CS5463WriteReg(REG_CONFR,RX_Buff);         //        #define REG_CONFR           0x40           //配置
  254. //----------------------
  255. //初始化--操作寄存器
  256. RX_Buff[0] = 0x00; //B0000_0000;  //这是什么鬼 可以这样吗？                                                  
  257. RX_Buff[1] = 0x00;//B0000_0000;
  258. RX_Buff[2] = 0x60;//B0110_0000;
  259. CS5463WriteReg(REG_MODER,RX_Buff);          //#define REG_MODER           0x64          //操作模式
  260. //----------------------
  261. //初始化--电流 交流偏置 校准寄存器
  262. // RW24XX(RX_Buff,3,EE_IACBIAS,0xA1);
  263. // CS5463WriteReg(REG_IACOFF,RX_Buff);        
  264. //----------------------
  265. //初始化--电流 增益校准寄存器
  266. // RW24XX(RX_Buff,3,EE_IACGAIN,0xA1);
  267. // CS5463WriteReg(REG_IGN,RX_Buff);               
  268. //----------------------
  269. //初始化--电压 交流偏置 校准寄存器
  270. // RW24XX(RX_Buff,3,EE_VACBIAS,0xA1);
  271. // CS5463WriteReg(REG_VACOFF,RX_Buff);        
  272. //----------------------
  273. //初始化--电压 增益校准寄存器
  274. // RW24XX(RX_Buff,3,EE_VACGAIN,0xA1);
  275. // CS5463WriteReg(REG_VGN,RX_Buff);               
  276. //----------------------
  277. RX_Buff[0] = 0x00;
  278. RX_Buff[1] = 0x0F;
  279. RX_Buff[2] = 0xA0;                                                //#define REG_CYCCONT         0x4A           //一个计算周期的A/D转换数
  280. CS5463WriteReg(REG_CYCCONT,RX_Buff);        //初始化--CYCLE COUNT 寄存器,4000
  281. //----------------------
  282. //初始化--脉冲速率寄存器
  283. // RX_Buff[0] = 0x00;
  284. // RX_Buff[1] = 0x34;
  285. // RX_Buff[2] = 0x9C;
  286. // CS5463WriteReg(REG_PULRATE,RX_Buff);        
  287. //----------------------
  288. RX_Buff[0] = 0xFF;
  289. RX_Buff[1] = 0xFF;
  290. RX_Buff[2] = 0xFF;
  291. CS5463WriteReg(REG_STATUSR,RX_Buff);        //初始化--状态寄存器  #define REG_STATUSR         0x5E         //状态
  292. //----------------------
  293. RX_Buff[0] = 0x80;                                                //开电流、电压、功率测量完毕中断
  294. RX_Buff[1] = 0x00;
  295. RX_Buff[2] = 0x80;                                                //开温度测量完毕中断
  296. CS5463WriteReg(REG_MASKR,RX_Buff);                //初始化--中断屏蔽寄存器    #define REG_MASKR           0x74          //中断屏蔽
  297. //----------------------
  298. RX_Buff[0] = 0x00;
  299. RX_Buff[1] = 0x00;
  300. RX_Buff[2] = 0x00;
  301. CS5463WriteReg(REG_CTRLR,RX_Buff);                //初始化--控制寄存器   #define REG_CTRLR           0x78          //控制  
  302. //----------------------
  303. CS5463CMD(CMD_STARTC);                                           //启动连续转换            #define CMD_STARTC           0XE8          //执行连续计算周期
  304. //CS5463_Status = 0;                                                //初始化任务进程状态
  305. //Load_Status = 0;
  306. //CS5463_CrmsSmallCunt = 0;
  307. //CS5463_CrmsOverCunt = 0;
  308. return(1);                    //只要做完这些步骤就返回true  1
  309. }
  310. /*************************************************************
  311. ** 函数名称:CS5463_ResetStatusReg
  312. ** 函数功能:复位状态寄存器函数
  313. ** 函数参数:无
  314. ** 创建时间:2009-9-15
  315. ** 第一次修改时间:无
  316. **************************************************************/
  317. static void CS5463_ResetStatusReg(void)
  318. {
  319. RX_Buff[0] = 0xFF;
  320. RX_Buff[1] = 0xFF;
  321. RX_Buff[2] = 0xFF;
  322. CS5463WriteReg(0x5E,RX_Buff);                //复位状态寄存器        #define REG_STATUSR         0x5E         //状态  
  323. }
  324. /*************************************************************
  325. ** 函数名称:CS5463_GetStatusReg
  326. ** 函数功能:读取状态寄存器函数
  327. ** 函数参数:无
  328. ** 创建时间:2009-9-15
  329. ** 第一次修改时间:无
  330. **************************************************************/
  331. static uint8 CS5463_GetStatusReg(void)
  332. {
  333. uint8 sta=0;
  334. CS5463ReadReg(0x1E,RX_Buff);           //1E 是什么？   状态寄存器
  335. if(RX_Buff[0]&0x80)                                           //检测：电流、电压、功率测量是否完毕
  336. {
  337.         //检测电流/电压是否超出范围
  338.         //检测电流有效值/电压有效值/电能是否超出范围
  339.         if((RX_Buff[0]&0x03)||(RX_Buff[1]&0x70))
  340.         {
  341.                  CS5463_ResetStatusReg();                //复位状态寄存器
  342.         }
  343.         else
  344.         {
  345.                 sta |= 0x01;//B0000_0001;        //这什么意思 还可以这样写吗？ PT2017-2-8   分隔符吗？
  346.         }
  347. }

  349. if(RX_Buff[2]&0x80)                                   //检测：温度测量是否完毕
  350. {
  351.           sta |=0x02; //B0000_0010;
  352. }
  353. return(sta);        
  354. }  







  362. void DelayM(unsigned int a)       //延时函数 1MS/次        
  363. {
  364.                 unsigned char i;
  365.                 while( --a != 0)
  366.        {               
  367.                 for(i = 0; i < 125; i++);  //一个 ; 表示空语句,CPU空转从0加到125，CPU大概就耗时1毫秒?
  368.                 }                                      
  369. }

  371. void Delay(int num)//延时函数
  372. {
  373.         while(num--);
  374. }

  376. /******************************************************************************/
  377. //写指令或数据  （0，指令） （1，数据）
  378. void LCM_WriteDatOrCom(bit dat_comm,uchar content)
  379. {
  380.   uchar a,i,j;
  381.   Delay(50);
  382.   a=content;
  383.   LCM_cs=1;
  384.   LCM_sclk=0;
  385.   LCM_std=1;
  386.   for(i=0;i<5;i++)
  387.   {
  388.     LCM_sclk=1;
  389.     LCM_sclk=0;
  390.   }
  391.   LCM_std=0;
  392.   LCM_sclk=1;
  393.   LCM_sclk=0;
  394.   if(dat_comm)
  395.     LCM_std=1;   //data
  396.   else
  397.    LCM_std=0;   //command
  398.   LCM_sclk=1;
  399.   LCM_sclk=0;
  400.   LCM_std=0;
  401.   LCM_sclk=1;
  402.   LCM_sclk=0;
  403.   for(j=0;j<2;j++)
  404.   {
  405.     for(i=0;i<4;i++)
  406.     {
  407.       a=a<<1;
  408.       LCM_std=CY;
  409.       LCM_sclk=1;
  410.       LCM_sclk=0;
  411.     }
  412.     LCM_std=0;
  413.     for(i=0;i<4;i++)
  414.     {
  415.       LCM_sclk=1;
  416.       LCM_sclk=0;
  417.     }
  418.   }
  419. }
  420. /*********************************************************************************/


  423. /*****************************************************************************/
  424. //初始化LCM
  425. void LCM_init(void)         
  426. {
  427.   LCM_rst=1;
  428.   LCM_psb=0;
  429.   LCM_WriteDatOrCom (0,0x30);  /*30---基本指令动作*/   
  430.   LCM_WriteDatOrCom (0,0x01);  /*清屏，地址指针指向00H*/
  431.   Delay (100);
  432.   LCM_WriteDatOrCom (0,0x06);  /*光标的移动方向*/
  433.   LCM_WriteDatOrCom(0,0x0c);   /*开显示，关游标*/
  434. }

  436. void chn_disp (uchar code *chn)   //显示4行 指针
  437. {
  438.   uchar i,j;
  439.   LCM_WriteDatOrCom  (0,0x30);         //        0 是指令 这2个命令 是干什么 的？
  440.   LCM_WriteDatOrCom  (0,0x80);         //
  441.   for (j=0;j<4;j++)
  442.   {
  443.     for (i=0;i<16;i++)
  444.     LCM_WriteDatOrCom  (1,chn[j*16+i]);
  445.   }
  446. }
  447. /*****************************************************************************/
  448. //清屏函数
  449. void LCM_clr(void)
  450. {
  451.   LCM_WriteDatOrCom (0,0x30);
  452.   LCM_WriteDatOrCom (0,0x01);   /*清屏，地址指针指向00H*/
  453.   Delay (180);
  454. }
  455. /*****************************************************************************/
  456. //向LCM发送一个字符串,长度64字符之内。
  457. //应用：LCM_WriteString("您好！");
  458. void LCM_WriteString(unsigned char *str)
  459. {
  460.                 while(*str != '\0')
  461.        {
  462.                         LCM_WriteDatOrCom(1,*str++);
  463.         }
  464.                 *str = 0;          //这里是什么意思 指针归0吗？
  465. }

  467. /*************************************************************
  468. ** 函数名称:CS5463_GetCurrentRMS
  469. ** 函数功能:读取电流有效值函数
  470. ** 函数参数:无
  471. ** 创建时间:2009-9-15
  472. ** 第一次修改时间:无
  473. **************************************************************/
  474. static void CS5463_GetCurrentRMS(void)
  475. {
  476. fp32 G = 0.5,result;
  477. uint32 temp1;
  478. uint8 temp,i,j;
  479. CS5463ReadReg(REG_IRMSR,RX_Buff);                   //读取电流有效值
  480. //SndCom1Data(RX_Buff,3);
  481. i = 0;
  482. result = 0;
  483. while(i<3)
  484. {
  485.           temp = RX_Buff[i];                                          
  486.         j = 0;
  487.         while(j<8)
  488.         {
  489.                  if(temp&0x80)
  490.                 {
  491.                          result += G;        
  492.                 }
  493.                 temp <<= 1;
  494.                 j++;
  495.                 G = G/2;        
  496.         }
  497.         i++;
  498. }
  499. result = result*CS5463_IScale;//I_Coff;                                                //计算电流值 暂时不用
  500. result *= 1000;                                                                //单位mA(毫安)  12345ma
  501. temp1 = (uint32)result;

  503. LCM_WriteDatOrCom  (0,0x94);
  504.         aa=        temp1/10000;
  505.         LCM_WriteDatOrCom(1,aa+0x30);
  506.         bb=        (temp1%10000)/1000;
  507.         LCM_WriteDatOrCom(1,bb+0x30);
  508.         cc=(temp1%1000)/100;
  509.         LCM_WriteDatOrCom(1,cc+0x30);
  510. //        LCM_WriteDatOrCom(1,0x2e);  //小数点  不需要小数点
  511.         dd=        (temp1%100)/10;
  512.         LCM_WriteDatOrCom(1,dd+0x30);
  513.         ee=temp1%10;
  514.         LCM_WriteDatOrCom(1,ee+0x30);
  515.         LCM_WriteString(" mA");

  517. // MeasureData[4] = (uint8)(temp1>>24);
  518. // MeasureData[5] = (uint8)(temp1>>16);
  519. // MeasureData[6] = (uint8)(temp1>>8);
  520. // MeasureData[7] = (uint8)temp1;
  521. // if(0x55==RelayQuery())                                                          //检查继电器是否闭合
  522. // {
  523. //         if(temp1<100)                                                                //检查电流是否小于100mA
  524. //         {
  525. //                CS5463_CrmsSmallCunt++;
  526. //                if(CS5463_CrmsSmallCunt>10)
  527. //                {
  528. //                        CS5463_CrmsSmallCunt = 0;
  529. //                        Load_Status = 0x55;                                        //设置灯状态为：开灯并电流过小
  530. //                        if(!CS5463LightFailure_PF)                          //检查该报警是否已经回应
  531. //                        {
  532. //                                if(!CS5463LightFailure_nF)                //检查定时重发标志
  533. //                                {
  534. //                                        Comm_ReportLightFailure(MeasureData+4);
  535. //                                        CS5463LightFailure_nF = 1;
  536. //                                        CS5463LightFailure_T = 1;
  537. //                                }
  538. //                        }
  539. //                }
  540. //         }
  541. //         else if(temp1>5000)                                                        //过流检测：5000mA
  542. //         {
  543. //                CS5463_CrmsOverCunt++;
  544. //                if(CS5463_CrmsOverCunt>2)
  545. //                {
  546. //                        CS5463_CrmsOverCunt = 0;
  547. //                        //RelayCtrl(0);                                                //断开继电器
  548. //                        Comm_ReportOverLoad(MeasureData+4);        //报告过流信息
  549. //                }
  550. //         }
  551. //        else                                                                                  //如果电流正常
  552. //        {
  553. //                CS5463_CrmsSmallCunt = 0;
  554. //                 CS5463_CrmsOverCunt = 0;
  555. //                Load_Status = 0xAA;                                                //设置灯状态为：开灯并正常
  556. //                CS5463LightFailure_PF = 0;                                   //复位报警标志
  557. //        }
  558. // }
  559. }



  563. /*************************************************************
  564. ** 函数名称:CS5463_GetPactiveRMS
  565. ** 函数功能:读取有功功率函数
  566. ** 函数参数:无
  567. ** 创建时间:2009-9-15
  568. ** 第一次修改时间:无
  569. **************************************************************/
  570. static void CS5463_GetPactiveRMS(void)
  571. {
  572. fp32 G = 1.0,result;
  573. uint8 temp,i,j;
  574. uint32 temp1;
  575. CS5463ReadReg(0x14,RX_Buff);           //读取有功功率REG_Pactive
  576. //SndCom1Data(RX_Buff,3);
  577. temp = RX_Buff[0];
  578. if(temp&0x80)                                                          //如果为负数，计算原码
  579. {
  580.           RX_Buff[0] = ~RX_Buff[0];                        //本来为取反+1，这里因为精度的原因，不+1
  581.         RX_Buff[1] = ~RX_Buff[1];
  582.         RX_Buff[2] = ~RX_Buff[2];                        
  583. }
  584. i = 0;
  585. result = 0;
  586. while(i<3)
  587. {
  588.           temp = RX_Buff[i];                                          
  589.         j = 0;
  590.         while(j<8)
  591.         {
  592.                  if(temp&0x80)
  593.                 {
  594.                          result += G;        
  595.                 }
  596.                 temp <<= 1;
  597.                 j++;
  598.                 G = G/2;        
  599.         }
  600.         i++;
  601. }
  602. // result = result*P_Coff;                                //计算功率，单位W(瓦特)
  603. // result = Vrms*Irms;                                        ////////直接计算功率
  604.   result = result*13125;
  605. temp1 = (uint32)result;

  607.   LCM_WriteDatOrCom  (0,0x8C);                //26W  12345W
  608.         aa=        temp1/10000;
  609.         LCM_WriteDatOrCom(1,aa+0x30);
  610.         bb=        (temp1%10000)/1000;
  611.         LCM_WriteDatOrCom(1,bb+0x30);
  612.         cc=(temp1%1000)/100;
  613.         LCM_WriteDatOrCom(1,cc+0x30);
  614. //        LCM_WriteDatOrCom(1,0x2e);  //小数点  不需要小数点
  615.         dd=        (temp1%100)/10;
  616.         LCM_WriteDatOrCom(1,dd+0x30);
  617.         ee=temp1%10;
  618.         LCM_WriteDatOrCom(1,ee+0x30);
  619.         LCM_WriteString(" W");


  622. // MeasureData[8] = (uint8)(temp1>>24);
  623. // MeasureData[9] = (uint8)(temp1>>16);
  624. // MeasureData[10] = (uint8)(temp1>>8);
  625. // MeasureData[11] = (uint8)temp1;
  626. }
  627. /*************************************************************
  628. ** 函数名称:CS5463_GetPowerFactor
  629. ** 函数功能:读取功率因数函数
  630. ** 函数参数:无
  631. ** 创建时间:2009-11-02
  632. ** 第一次修改时间:无
  633. **************************************************************/
  634. static void CS5463_GetPowerFactor(void)
  635. {
  636. fp32 G = 1.0,result;
  637. uint8 temp,i,j;
  638. uint32 temp1;
  639. CS5463ReadReg(0x32,RX_Buff);                   //读取功率因数
  640. //SndCom1Data(RX_Buff,3);
  641. temp = RX_Buff[0];
  642. if(temp&0x80)                                                          //如果为负数，计算原码
  643. {
  644.           RX_Buff[0] = ~RX_Buff[0];                        //本来为取反+1，这里因为精度的原因，不+1
  645.         RX_Buff[1] = ~RX_Buff[1];
  646.         RX_Buff[2] = ~RX_Buff[2];                        
  647. }
  648. i = 0;
  649. result = 0;
  650. while(i<3)
  651. {
  652.           temp = RX_Buff[i];                                          
  653.         j = 0;
  654.         while(j<8)
  655.         {
  656.                  if(temp&0x80)
  657.                 {
  658.                          result += G;        
  659.                 }
  660.                 temp <<= 1;
  661.                 j++;
  662.                 G = G/2;        
  663.         }
  664.         i++;
  665. }
  666. result *= 10000;
  667. temp1 = (uint32)result;
  668. // MeasureData[12] = (uint8)(temp1>>24);
  669. // MeasureData[13] = (uint8)(temp1>>16);
  670. // MeasureData[14] = (uint8)(temp1>>8);
  671. // MeasureData[15] = (uint8)temp1;
  672. }

  674. /*************************************************************
  675. ** 函数名称:CS5463_GetTemperature
  676. ** 函数功能:读取温度函数
  677. ** 函数参数:无
  678. ** 创建时间:2009-11-03
  679. ** 第一次修改时间:无
  680. **************************************************************/
  681. static void CS5463_GetTemperature(void)          //温度能显示了 PT2017-2-12
  682. {
  683. fp32 G = 128,result;
  684. uint8 temp,i,j,pn=0;
  685. uint32 temp1;
  686. CS5463ReadReg(0x26,RX_Buff);                   //读取温度        是的在这里就读到了温度
  687. //SndCom1Data(RX_Buff,3);
  688. temp = RX_Buff[0];
  689. if(temp&0x80)                                                          //如果为负数，计算原码
  690. {
  691.           pn = 1;                                                                //负数标志
  692.         RX_Buff[0] = ~RX_Buff[0];                        //本来为取反+1，这里因为精度的原因，不+1
  693.         RX_Buff[1] = ~RX_Buff[1];
  694.         RX_Buff[2] = ~RX_Buff[2];                        
  695. }
  696. i = 0;
  697. result = 0;    //这个值是浮点数 先清零 再逐个把0.5的权 数据加进来
  698. while(i<3)
  699. {
  700.           temp = RX_Buff[i];        //虽然这个数组定义了4个字节 实际就用了 Buff[0]  Buff[1]  RX_Buff[2]                                   
  701.         j = 0;
  702.         while(j<8)
  703.         {
  704.                  if(temp&0x80)
  705.                 {
  706.                          result += G;        //把0.5的权数据加进来                  
  707.                 }
  708.                 temp <<= 1;
  709.                 j++;
  710.                 G = G/2;        
  711.         }
  712.         i++;
  713. }
  714. if(result<128)                          //是的这个result 是 -127，128   这里已经获取了温度浮点值 最多是一个3位数？ 还有小数点
  715. {
  716.          result *= 100;
  717.         temp1 = (uint32)result;          //是的 这里就是 例如12523  -----> 125.23  怎么去显示？ 如何分离 从8A开始显示

  719.             LCM_WriteDatOrCom  (0,0x9C);        // 显示起始位置  第4行
  720.                 aa=        temp1/ 10000;
  721.                 LCM_WriteDatOrCom(1,aa+0x30);         //怎么分离出来显示 PT2017-2-9
  722.                 bb=temp1/1000- aa*10;
  723.                 LCM_WriteDatOrCom(1,bb+0x30);

  725.                 cc=        temp1/100- aa*100-bb*10;
  726.                 LCM_WriteDatOrCom(1,cc+0x30);
  727.             LCM_WriteDatOrCom(1,0x2e);         //"."
  728.                 dd=        (temp1%100)/10;
  729.                 LCM_WriteDatOrCom(1,dd+0x30);
  730.                 ee=temp1%10;
  731.                 LCM_WriteDatOrCom(1,ee+0x30);
  732.                 LCM_WriteString("℃");


  735. //                  PT2017-2-12 显示3个字节的 十六进制数据
  736. //
  737. //            LCM_WriteDatOrCom  (0,0x9D);        // 显示起始位置
  738. //                        a=RX_Buff[0]/16;
  739. //                        if(a<10)
  740. //                        {
  741. //                        LCM_WriteDatOrCom(1,a+0x30);
  742. //                        }
  743. //                        else
  744. //                        {
  745. //                         LCM_WriteDatOrCom(1,a+0x37);  //为什么多了7个？
  746. //                        }
  747. //                        b=RX_Buff[0]%16;
  748. //
  749. //                         if(b<10)
  750. //                        {
  751. //                        LCM_WriteDatOrCom(1,b+0x30);
  752. //                        }
  753. //                        else
  754. //                        {
  755. //                         LCM_WriteDatOrCom(1,b+0x37);
  756. //                        }
  757. //
  758. //                        a=RX_Buff[1]/16;
  759. //
  760. //                        if(a<10)
  761. //                        {
  762. //                        LCM_WriteDatOrCom(1,a+0x30);
  763. //                        }
  764. //                        else
  765. //                        {
  766. //                         LCM_WriteDatOrCom(1,a+0x37);  //为什么多了7个？
  767. //                        }
  768. //                        b=RX_Buff[1]%16;
  769. //
  770. //                         if(b<10)
  771. //                        {
  772. //                        LCM_WriteDatOrCom(1,b+0x30);
  773. //                        }
  774. //                        else
  775. //                        {
  776. //                         LCM_WriteDatOrCom(1,b+0x37);
  777. //                        }
  778. //                        
  779. //
  780. //
  781. //                        a=RX_Buff[2]/16;
  782. //
  783. //                        if(a<10)
  784. //                        {
  785. //                        LCM_WriteDatOrCom(1,a+0x30);
  786. //                        }
  787. //                        else
  788. //                        {
  789. //                         LCM_WriteDatOrCom(1,a+0x37);  //为什么多了7个？
  790. //                        }
  791. //                        b=RX_Buff[2]%16;
  792. //
  793. //                         if(b<10)
  794. //                        {
  795. //                        LCM_WriteDatOrCom(1,b+0x30);
  796. //                        }
  797. //                        else
  798. //                        {
  799. //                         LCM_WriteDatOrCom(1,b+0x37);
  800. //                        }

  802. }
  803. }
  804. /*************************************************************
  805. ** 函数名称:CS5463_GetVoltRMS
  806. ** 函数功能:读取电压有效值函数
  807. ** 函数参数:无
  808. ** 创建时间:2009-9-15
  809. ** 第一次修改时间:2009-9-23，修改电压系数（需验证）
  810. ** 第二次修改时间:2010-3-22，设定测量读数小于100V时数据无效
  811. ** 第三次修改时间:
  812. **************************************************************/
  813. static void CS5463_GetVoltRMS(void)                 //这个函数啥意思？         PT2017-2-12 电压显示OK
  814. {
  815. float G = 0.5,result;                //typedef float          fp32;          就是浮点类型
  816. int temp1;                          //  int
  817. uint8 temp,i,j;                  //  byte
  818. CS5463ReadReg(REG_VRMSR,RX_Buff);                   //读取电压有效值            这里就读到了吗？  是
  819. //SndCom1Data(RX_Buff,3);                                        //#define REG_VRMSR           0x58        //电压有效值  电压有效值0x58吗？是写
  820. i = 0;
  821. result = 0;
  822. while(i<3)
  823. {
  824.           temp = RX_Buff[i];                                          
  825.         j = 0;
  826.         while(j<8)
  827.         {
  828.                  if(temp&0x80)
  829.                 {
  830.                          result += G;        
  831.                 }
  832.                 temp <<= 1;
  833.                 j++;
  834.                 G = G/2;        
  835.         }
  836.         i++;                                                               
  837. }                                                                                //电压在220时取样电压为78mv
  838. result = result*CS5463_VScale;//V_Coff;                                //计算电压值220V*250mv/(110mv/1.414)=704.8V            可以暂时不用  
  839. // if(result<=100)return;                                        //如果测量读出电压小于100V，确认读数错误
  840. result *= 100;                                                //单位为mV（毫伏） 12345mv  5位你怎么显示
  841. temp1 = (uint32)result;

  843.         LCM_WriteDatOrCom  (0,0x84);
  844.         aa=        temp1/10000;
  845.         LCM_WriteDatOrCom(1,aa+0x30);
  846.         bb=        (temp1%10000)/1000;
  847.         LCM_WriteDatOrCom(1,bb+0x30);
  848.         cc=(temp1%1000)/100;
  849.         LCM_WriteDatOrCom(1,cc+0x30);
  850.         LCM_WriteDatOrCom(1,0x2e);
  851.         dd=        (temp1%100)/10;
  852.         LCM_WriteDatOrCom(1,dd+0x30);
  853.         ee=temp1%10;
  854.         LCM_WriteDatOrCom(1,ee+0x30);
  855.         LCM_WriteString(" V");



  859. // MeasureData[0] = (uint8)(temp1>>24);
  860. // MeasureData[1] = (uint8)(temp1>>16);
  861. // MeasureData[2] = (uint8)(temp1>>8);
  862. // MeasureData[3] = (uint8)temp1;        
  863. }

  865. void main()
  866. {
  867.    CS5463_Init();
  868.     LCM_init();       //初始化液晶显示器
  869.         LCM_clr();       //清屏
  870.         chn_disp(tab1); //显示欢迎字
  871.         DelayM(500);  //显示等留3秒
  872.         // LCM_clr();       //清屏
  873.    
  874.          
  875.           while(1)
  876.           {
  877.         //        if(INT)break;                                                        //检查中断信号

  879.                 sta        = CS5463_GetStatusReg();                          //检测中断产生的原因
  880.                 if(0x01==(sta&0x01))                                           //读取电流电压
  881.                 {        
  882.         //                CS5463Monitor_Cunt = 0;                                //如果有中断，表明芯片正常工作，清除监控定时器
  883.                         CS5463_ResetStatusReg();                        //清除标志
  884.                         CS5463_GetVoltRMS();                                //获取电压
  885.                         CS5463_GetCurrentRMS();                                //获取电流
  886.                         CS5463_GetPactiveRMS();                                //获取功率
  887. //                        CS5463_GetPowerFactor();                        //获取功率因数
  888.                         if(0x02==(sta&0x02))                                //读取温度
  889.                         {        
  890.                         CS5463_GetVoltRMS();                                //获取电压                                                               
  891.                         CS5463_GetTemperature();                    //温度读取不需要太频繁，所以跟电流电压一起读取

  893.                                 //CS5463_Init();                                //重新初始化芯片
  894.                         }                                                
  895.                         //SndCom1Data(MeasureData,16);
  896.                 }





  902.                 //   read_register(0x18,(void *)r); //读取Vrms寄存器值



  906. //                        LCM_WriteDatOrCom  (0,0x85);        // 显示起始位置           PT 2017-2-12 不用显示了
  907. //                        a=sta/16;   //这个sta变成0 了怎么办？
  908. //                        if(a<10)
  909. //                        {
  910. //                        LCM_WriteDatOrCom(1,a+0x30);
  911. //                        }
  912. //                        else
  913. //                        {
  914. //                         LCM_WriteDatOrCom(1,a+0x37);  //为什么多了7个？
  915. //                        }
  916. //                        b=sta%16;
  917. //
  918. //                         if(b<10)
  919. //                        {
  920. //                        LCM_WriteDatOrCom(1,b+0x30);
  921. //                        }
  922. //                        else
  923. //                        {
  924. //                         LCM_WriteDatOrCom(1,b+0x37);
  925. //                        }


  928. //
  929. //                        a=r[1]/16;
  930. //
  931. //                        if(a<10)
  932. //                        {
  933. //                        LCM_WriteDatOrCom(1,a+0x30);
  934. //                        }
  935. //                        else
  936. //                        {
  937. //                         LCM_WriteDatOrCom(1,a+0x37);  //为什么多了7个？
  938. //                        }
  939. //                        b=r[1]%16;
  940. //
  941. //                         if(b<10)
  942. //                        {
  943. //                        LCM_WriteDatOrCom(1,b+0x30);
  944. //                        }
  945. //                        else
  946. //                        {
  947. //                         LCM_WriteDatOrCom(1,b+0x37);
  948. //                        }
  949. //                        
  950. //
  951. //
  952. //                        a=r[2]/16;
  953. //
  954. //                        if(a<10)
  955. //                        {
  956. //                        LCM_WriteDatOrCom(1,a+0x30);
  957. //                        }
  958. //                        else
  959. //                        {
  960. //                         LCM_WriteDatOrCom(1,a+0x37);  //为什么多了7个？
  961. //                        }
  962. //                        b=r[2]%16;
  963. //
  964. //                         if(b<10)
  965. //                        {
  966. //                        LCM_WriteDatOrCom(1,b+0x30);
  967. //                        }
  968. //                        else
  969. //                        {
  970. //                         LCM_WriteDatOrCom(1,b+0x37);
  971. //                        }
  972. //
  973. //
  974. //
  975. //
  976. //                        // read_register(0x16,(void *)r); //读取Irms寄存器值，并通过串口发送
  977. //
  978. //                        LCM_WriteDatOrCom  (0,0x95);        // 显示起始位置
  979. //                        a=r[0]/16;
  980. //                        if(a<10)
  981. //                        {
  982. //                        LCM_WriteDatOrCom(1,a+0x30);
  983. //                        }
  984. //                        else
  985. //                        {
  986. //                         LCM_WriteDatOrCom(1,a+0x37);  //为什么多了7个？
  987. //                        }
  988. //                        b=r[0]%16;
  989. //
  990. //                         if(b<10)
  991. //                        {
  992. //                        LCM_WriteDatOrCom(1,b+0x30);
  993. //                        }
  994. //                        else
  995. //                        {
  996. //                         LCM_WriteDatOrCom(1,b+0x37);
  997. //                        }
  998. //
  999. //                        a=r[1]/16;
  1000. //
  1001. //                        if(a<10)
  1002. //                        {
  1003. //                        LCM_WriteDatOrCom(1,a+0x30);
  1004. //                        }
  1005. //                        else
  1006. //                        {
  1007. //                         LCM_WriteDatOrCom(1,a+0x37);  //为什么多了7个？
  1008. //                        }
  1009. //                        b=r[1]%16;
  1010. //
  1011. //                         if(b<10)
  1012. //                        {
  1013. //                        LCM_WriteDatOrCom(1,b+0x30);
  1014. //                        }
  1015. //                        else
  1016. //                        {
  1017. //                         LCM_WriteDatOrCom(1,b+0x37);
  1018. //                        }
  1019. //                        
  1020. //
  1021. //
  1022. //                        a=r[2]/16;
  1023. //
  1024. //                        if(a<10)
  1025. //                        {
  1026. //                        LCM_WriteDatOrCom(1,a+0x30);
  1027. //                        }
  1028. //                        else
  1029. //                        {
  1030. //                         LCM_WriteDatOrCom(1,a+0x37);  //为什么多了7个？
  1031. //                        }
  1032. //                        b=r[2]%16;
  1033. //
  1034. //                         if(b<10)
  1035. //                        {
  1036. //                        LCM_WriteDatOrCom(1,b+0x30);
  1037. //                        }
  1038. //                        else
  1039. //                        {
  1040. //                         LCM_WriteDatOrCom(1,b+0x37);
  1041. //                        }










  1052.                          //   read_register(0x14,(void *)r); //读取Irms寄存器值，并通过串口发送

  1054. //                        LCM_WriteDatOrCom  (0,0x8D);        // 显示起始位置
  1055. //                        a=r[0]/16;
  1056. //                        if(a<10)
  1057. //                        {
  1058. //                        LCM_WriteDatOrCom(1,a+0x30);
  1059. //                        }
  1060. //                        else
  1061. //                        {
  1062. //                         LCM_WriteDatOrCom(1,a+0x37);  //为什么多了7个？
  1063. //                        }
  1064. //                        b=r[0]%16;
  1065. //
  1066. //                         if(b<10)
  1067. //                        {
  1068. //                        LCM_WriteDatOrCom(1,b+0x30);
  1069. //                        }
  1070. //                        else
  1071. //                        {
  1072. //                         LCM_WriteDatOrCom(1,b+0x37);
  1073. //                        }
  1074. //
  1075. //                        a=r[1]/16;
  1076. //
  1077. //                        if(a<10)
  1078. //                        {
  1079. //                        LCM_WriteDatOrCom(1,a+0x30);
  1080. //                        }
  1081. //                        else
  1082. //                        {
  1083. //                         LCM_WriteDatOrCom(1,a+0x37);  //为什么多了7个？
  1084. //                        }
  1085. //                        b=r[1]%16;
  1086. //
  1087. //                         if(b<10)
  1088. //                        {
  1089. //                        LCM_WriteDatOrCom(1,b+0x30);
  1090. //                        }
  1091. //                        else
  1092. //                        {
  1093. //                         LCM_WriteDatOrCom(1,b+0x37);
  1094. //                        }
  1095. //                        
  1096. //
  1097. //
  1098. //                        a=r[2]/16;
  1099. //
  1100. //                        if(a<10)
  1101. //                        {
  1102. //                        LCM_WriteDatOrCom(1,a+0x30);
  1103. //                        }
  1104. //                        else
  1105. //                        {
  1106. //                         LCM_WriteDatOrCom(1,a+0x37);  //为什么多了7个？
  1107. //                        }
  1108. //                        b=r[2]%16;
  1109. //
  1110. //                         if(b<10)
  1111. //                        {
  1112. //                        LCM_WriteDatOrCom(1,b+0x30);
  1113. //                        }
  1114. //                        else
  1115. //                        {
  1116. //                         LCM_WriteDatOrCom(1,b+0x37);
  1117. //                        }



  1121.                 //          read_register(0x26,(void *)r); //温度

  1123.                 //        T=125;            //对于不确定长度的 怎么办？ 2位小数就很不错了 所以这里就是把小数*100在去显示 int类型变量怎么办？
  1124. //                        LCM_WriteDatOrCom  (0,0x95);        // 显示起始位置
  1125. //                        aa=T/100;                 //怎么提取出来1呢 ？
  1126. //                        LCM_WriteDatOrCom(1,aa+0x30);        //显示温度十位                 先看懂这里 0-9的就是+0x30 就可以 这里就是写数据  
  1127. //                        bb=T/10-aa*10;         //这个2 是怎么提取的呢？ 12-10*1=2
  1128. //                        LCM_WriteDatOrCom(1,bb+0x30);        //个位
  1129. //                        LCM_WriteDatOrCom(1,0x2e);         //"."
  1130. //                        cc=T-aa*100-bb*10;          //再看这个5是如何提取出来的呢？ 125- 100-20 =5  有更好的提取方法吗？
  1131. //                        LCM_WriteDatOrCom(1,cc+0x30); //小位1位
  1132. //                        LCM_WriteString("℃");        
  1133. //                        T=T+1;
  1134. //                        DelayM(50);
  1135.                 }


  1138. }
复制代码

所有资料51hei提供下载:
12864-CS5463-STC89S52源代码-2017-7-9OK.zip (68.94 KB, 下载次数: 27)


评分

参与人数 2黑币 +10 收起 理由
muzhi + 5 赞一个！
卡西莫多i + 5 绝世好帖！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶1 踩踩
回复

使用道具 举报

沙发
ID:321933 发表于 2018-5-24 23:56 | 只看该作者
非常感谢分享！在做毕设中，有很大的参考价值
回复

使用道具 举报

板凳
ID:321933 发表于 2018-6-3 22:59 | 只看该作者
可以问一下我把程序烧录进去，显示屏却没有显示啊，这里有设定好显示数据位置的函数吗？
回复

使用道具 举报

地板
ID:321933 发表于 2018-6-3 23:14 | 只看该作者
想问一下烧录了程序，显示屏却不显示，QAQ有什么解决方案吗？
回复

使用道具 举报

5#
ID:615920 发表于 2019-9-24 21:56 | 只看该作者
想问一下烧录了程序，显示屏却不显示，QAQ有什么解决方案吗？
回复

使用道具 举报

6#
ID:73182 发表于 2019-9-25 08:11 | 只看该作者
有电路图吗
回复

使用道具 举报

7#
ID:616081 发表于 2019-9-25 11:18 | 只看该作者

谢谢楼主的分享
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表