您的位置 首页 报告

ADE7758驱动程序

2020年9月18日 16:30 阅读(330)

/**ade7758.c**Createdon:2014-9-12*Author:lzy*/#includestdio.h>#includedebug.h#includeade7758.h#in

  1. /*
  2. *ade7758.c
  3. *
  4. *Createdon:2014-9-12
  5. *Author:lzy
  6. */
  7. #include
  8. #include”debug.h”
  9. #include”ade7758.h”
  10. #include”SpiDev.h”
  12. unsigned char bWorkModel=0;//作业形式标志位 1：校准形式；0：正常作业形式;
  13. unsigned char bit_1s=0;//1s钟标志，在时钟中止函数中置位
  15. static unsigned char divider=1;//电能分频器，默认值为零，视在功率超出必定值时，主动将该值进步
  16. static unsignedintenergy[9];//用于累加电能值 36
  18. struct all_data working;//正常作业形式下寄存的电参量 95
  19. struct adjust_data adjusting;//校准形式下寄存的数据 65
  21. static unsignedintvo_buffer[5][3];//用于电压的积分虑波 36
  22. static unsignedintio_buffer[5][3];//用于电流的积分虑波 36
  24. static unsigned char b_adjust=0;//ADE7758现已校准标志
  25. static unsigned char sample_cycle=0;//电压采样周期，5次取均匀
  26. static unsigned char ADE_AdjustDataBuf[2+sizeof(struct adjust_dataw)]={0};/*校准数据暂存缓冲区*/
  28. void ADE_Check7758(void);
  30. /**
  31. *功用：延时函数 50us
  32. */
  33. void ADE_udelay(void)
  34. {
  35. //usleep(50);
  36. }
  38. /**
  39. *功用：片选使能
  40. */
  41. void ADE_CS(unsigned char cs)
  42. {
  43. //CSADE7758_A=cs;//=====
  44. }
  47. /**
  48. *功用：经过SPI写入数据至芯片
  49. *进口参数：
  50. *buf->数据缓冲区
  51. *len->数据长度
  52. */
  53. void ADE_SPIWrite(unsigned char*buf,unsigned charlen)
  54. {
  55. SPI_Write(buf,len);
  56. }
  59. /**
  60. *功用：经过SPI读芯片数据
  61. *进口参数：len->数据长度
  62. *出口参数：buf->数据缓冲区
  63. *
  64. */
  65. void ADE_SPIRead(unsigned char*buf,unsigned charlen)
  66. {
  67. SPI_Read(buf,len);
  68. }
  71. /**
  72. *功用：7758写数据函数
  73. *进口参数：
  74. *type:方针寄存器的地址
  75. *wdata:写进寄存器的内容
  76. *databit:方针寄存器的宽度
  77. *出口参数：NULL
  78. *返回值：NULL
  79. */
  80. void ADE_Write(unsigned char type,unsignedintwdata,unsigned char databit)
  81. {
  82. unsigned char data[3];
  84. ADE_CS(0);
  86. type=type|0x80;
  88. data[0]=type;
  89. ADE_SPIWrite(data,1);
  90. ADE_udelay();
  92. if(databit==8)
  93. {
  94. data[0]=wdata;
  95. ADE_SPIWrite(data,1);
  96. }
  97. elseif(databit==16)
  98. {
  99. data[0]=(wdata&0xff00)>>8;/*高8位*/
  100. data[1]=(wdata&0x00ff);/*底8位*/
  101. ADE_SPIWrite(data,2);
  102. }
  103. else
  104. pr_err(“ADE write databit Error:%d\n”,databit);
  105. ADE_CS(1);
  106. }
  108. /**
  109. *功用：7758读寄存器函数
  110. *进口参数：
  111. * type:方针寄存器的地址
  112. *databit:方针寄存器的宽度
  113. *出口参数：指定寄存器的内容
  114. *返回值：指定寄存器的内容
  115. */
  116. unsignedintADE_Read(unsigned char type,unsigned char databit)
  117. {
  118. unsigned char data[4]={0,0,0,0};
  119. unsignedintrtdata=0;
  121. ADE_CS(0);
  122. type=type&0x7F;
  124. data[0]=type;
  125. ADE_SPIWrite(data,1);
  126. ADE_udelay();
  128. if(databit==8)
  129. {
  130. ADE_SPIRead(data,1);
  131. rtdata=data[0];
  132. }
  133. elseif(databit==12)
  134. {
  135. ADE_SPIRead(data,2);
  136. rtdata=(data[0]&0x0f)<<8;
  137. rtdata+=data[1];
  138. }
  139. elseif(databit==16)
  140. {
  141. ADE_SPIRead(data,2);
  142. rtdata=data[0]<<8;
  143. rtdata+=data[1];
  144. }elseif(databit==24)
  145. {
  146. ADE_SPIRead(data,3);
  147. rtdata=data[0]<<16;
  148. rtdata+=(data[1]<<8);
  149. rtdata+=data[2];
  150. }
  151. else
  152. pr_err(“ADE Read databit Error:%d\n”,databit);
  153. ADE_CS(1);
  155. return(rtdata);
  156. }
  158. /**
  159. *功用：检测反常
  160. */
  161. void ADE_AuCheck(void)
  162. {
  163. unsigned char i;
  164. unsignedinttemp_data[5];//寄存运算进程的中心变量
  165. unsignedinttemp_v,temp_i;
  167. //主动检测ADE7758是否出现反常
  168. if(working.voltage[0]>ERR_VOLTAGE||
  169. working.voltage[1]>ERR_VOLTAGE||
  170. working.voltage[2]>ERR_VOLTAGE)
  171. {
  172. ADE_Check7758();
  173. }
  175. //主动设置分频器的巨细
  176. for(i=0;i<3;i++)
  177. {
  178. temp_v=working.voltage[i];
  179. temp_i=working.current[i];
  180. temp_data[i]=((temp_v*temp_i)/DIVI_VALUE)&0x000000ff;
  181. }
  183. temp_data[3]=(temp_data[0]>temp_data[1])?
  184. ((temp_data[0]>temp_data[2])?temp_data[0]:temp_data[2]):
  185. ((temp_data[1]>temp_data[2])?temp_data[1]:temp_data[2]);
  187. if(divider!=(char)temp_data[3])
  188. {
  189. //writetoade7758
  190. divider=(char)temp_data[3]+1;
  192. for(i=0;i<3;i++)
  193. ADE_Write(ADD_WDIV+i,((int)divider<<8),8);
  194. }
  195. }
  198. /**
  199. *功用：每秒读取功率
  200. */
  201. void ADE_ReadHR(void)
  202. {
  203. unsigned char i;
  204. unsignedinttemp_data[9];//寄存运算进程的中心变量
  206. //有功
  207. temp_data[ADD_AWATTHR-1]=ADE_Read(ADD_AWATTHR,16);
  208. temp_data[ADD_BWATTHR-1]=ADE_Read(ADD_BWATTHR,16);
  209. temp_data[ADD_CWATTHR-1]=ADE_Read(ADD_CWATTHR,16);
  210. //无功
  211. temp_data[ADD_AVARHR-1]=ADE_Read(ADD_AVARHR,16);
  212. temp_data[ADD_BVARHR-1]=ADE_Read(ADD_BVARHR,16);
  213. temp_data[ADD_CVARHR-1]=ADE_Read(ADD_CVARHR,16);
  214. //视在
  215. temp_data[ADD_AVAHR-1]=ADE_Read(ADD_AVAHR,16);
  216. temp_data[ADD_BVAHR-1]=ADE_Read(ADD_BVAHR,16);
  217. temp_data[ADD_CVAHR-1]=ADE_Read(ADD_CVAHR,16);
  219. for(i=0;i<9;i++)
  220. {
  221. if(temp_data[i]>0x7fff)
  222. temp_data[i]=0xffff-temp_data[i]+1;
  223. }
  225. if(divider>1)
  226. {
  227. for(i=0;i<9;i++)
  228. temp_data[i]=temp_data[i]*divider;//乘上分频器的值
  229. }
  231. //能量的核算
  232. for(i=0;i<9;i++)
  233. energy[i]+=temp_data[i];//累加电能值，单位为 WS（瓦秒）
  235. //转换成千瓦时
  236. for(i=0;i<3;i++)
  237. {
  238. working.watt_hour[i]+=(energy[i]/3600000);//转换成千瓦时
  239. energy[i]=energy[i]%3600000;
  240. }
  242. working.watt_hour[3]=working.watt_hour[0]+working.watt_hour[1]+working.watt_hour[2];//总和
  244. //转换成千伏安时
  245. for(i=0;i<3;i++)
  246. {
  247. working.va_hour[i]+=(energy[i+6]/3600000);//转换成千瓦时
  248. energy[i+6]=energy[i+6]%3600000;
  249. }
  251. working.va_hour[3]=working.va_hour[0]+working.va_hour[1]+working.va_hour[2];//总和
  253. for(working.watt[3]=0,i=0;i<3;i++)
  254. {
  255. working.watt[i]=temp_data[i]/1000;//千瓦
  256. working.watt[3]+=working.watt[i];
  257. }
  259. for(working.var[3]=0,i=0;i<3;i++)
  260. {
  261. working.var[i]=temp_data[i+3]/1000;
  262. working.var[3]+=working.var[i];
  263. }
  265. for(working.va[3]=0,i=0;i<3;i++)
  266. {
  267. working.va[i]=temp_data[i+6]/1000;//千伏安
  269. if(working.va[i]
  270. working.va[i]=working.watt[i];
  272. working.va[3]+=working.va[i];
  273. }
  276. }
  278. /**
  279. *功用：实时读取电流电压值
  280. */
  281. void ADE_ReadVC(void)
  282. {
  283. unsigned char i,j;
  285. for(i=0;i<3;i++)
  286. {
  287. working.voltage[i]=0;
  288. working.current[i]=0;
  289. }
  291. for(i=0;i<3;i++)
  292. {
  293. for(j=0;j<5;j++)
  294. {
  295. working.voltage[i]+=vo_buffer[j][i];
  296. working.current[i]+=io_buffer[j][i];
  297. }
  298. }
  300. for(i=0;i<3;i++)
  301. {
  302. working.voltage[i]=working.voltage[i]/5;
  303. working.current[i]=working.current[i]/5;
  304. }
  306. //电压电流的三相均匀值
  307. working.voltage[3]=(working.voltage[0]+working.voltage[1]+working.voltage[2])/3;
  308. working.current[3]=(working.current[0]+working.current[1]+working.current[2])/3;
  310. printf(” voltage=%d current=%d\n”,working.voltage[3],working.current[3]);
  311. }
  313. /**
  314. *校准形式下 每秒读取功率
  315. */
  316. void ADE_AdjustHR(void)
  317. {
  318. unsigned char i;
  319. unsignedinttemp_data[9];//寄存运算进程的中心变量
  321. //有功
  322. temp_data[ADD_AWATTHR-1]=ADE_Read(ADD_AWATTHR,16);
  323. temp_data[ADD_BWATTHR-1]=ADE_Read(ADD_BWATTHR,16);
  324. temp_data[ADD_CWATTHR-1]=ADE_Read(ADD_CWATTHR,16);
  325. //无功
  326. temp_data[ADD_AVARHR-1]=ADE_Read(ADD_AVARHR,16);
  327. temp_data[ADD_BVARHR-1]=ADE_Read(ADD_BVARHR,16);
  328. temp_data[ADD_CVARHR-1]=ADE_Read(ADD_CVARHR,16);
  329. //视在
  330. temp_data[ADD_AVAHR-1]=ADE_Read(ADD_AVAHR,16);
  331. temp_data[ADD_BVAHR-1]=ADE_Read(ADD_BVAHR,16);
  332. temp_data[ADD_CVAHR-1]=ADE_Read(ADD_CVAHR,16);
  334. for(i=0;i<3;i++)
  335. {
  336. adjusting.read_data.watt[i]=temp_data[i+0]&0x0000ffff;
  337. adjusting.read_data.var[i]=temp_data[i+3]&0x0000ffff;//没有校准有功功率
  338. adjusting.read_data.va[i]=temp_data[i+6]&0x0000ffff;
  339. }
  340. }
  343. /**
  344. *校准形式下实时读取电流电压值
  345. */
  346. void ADE_AdjustVC(void)
  347. {
  348. unsigned char i,j;
  350. for(i=0;i<3;i++)
  351. {
  352. adjusting.read_data.voltage[i]=0;
  353. adjusting.read_data.current[i]=0;
  354. }
  356. for(i=0;i<3;i++)
  357. {
  358. for(j=0;j<5;j++)
  359. {
  360. adjusting.read_data.voltage[i]+=vo_buffer[j][i];
  361. adjusting.read_data.current[i]+=io_buffer[j][i];
  362. }
  363. }
  365. for(i=0;i<3;i++)
  366. {
  367. adjusting.read_data.voltage[i]=adjusting.read_data.voltage[i]/5;
  368. adjusting.read_data.current[i]=adjusting.read_data.current[i]/5;
  369. }
  370. }
  373. /**
  374. *功用：从ADE7758中取出三相电压电流功率等电参量
  375. */
  376. void ADE_GetData(void)
  377. {
  378. static unsigned char bit_3s=0;
  379. unsigned char j;
  381. if(!bWorkModel)//正常作业形式
  382. {
  383. if(bit_1s)
  384. {
  385. bit_1s=0;
  386. ADE_ReadHR();
  388. if((bit_3s++)>=3)/*三秒检测一次反常*/
  389. {
  390. ADE_AuCheck();
  391. bit_3s=0;
  392. }
  393. }
  395. for(j=0;j<3;j++)
  396. {
  397. vo_buffer[sample_cycle][j]=ADE_Read(ADD_AVRMS+j,24)>>12;//voltage
  398. io_buffer[sample_cycle][j]=ADE_Read(ADD_AIRMS+j,24)>>13;//current
  399. }
  401. if(sample_cycle==4)/*读取5次取均匀值*/
  402. ADE_ReadVC();
  403. }
  404. else
  405. {
  406. if(bit_1s)
  407. {
  408. bit_1s=0;
  409. ADE_AdjustHR();
  410. }
  412. for(j=0;j<3;j++)
  413. {
  414. vo_buffer[sample_cycle][j]=ADE_Read(ADD_AVRMS+j,24);
  415. io_buffer[sample_cycle][j]=ADE_Read(ADD_AIRMS+j,24);
  416. }
  418. if(sample_cycle==4)
  419. ADE_AdjustVC();
  422. //save_set_to_e2prom();//===
  423. }
  425. if(sample_cycle<4)
  426. sample_cycle+=1;
  427. else
  428. sample_cycle=0;
  429. }
  432. /**
  433. *校准数据保存至缓冲区
  434. */
  435. void ADE_WriteByte(unsigned short data,unsigned short addr)
  436. {
  437. memcpy(ADE_AdjustDataBuf+addr,&data,sizeof(unsigned short));
  438. }
  441. /**
  442. *读取校准数据缓冲区中数据
  443. */
  444. unsigned short ADE_ReadByte(unsigned short addr)
  445. {
  446. unsigned short data;
  448. memcpy(&data,ADE_AdjustDataBuf+addr,sizeof(unsigned short));
  450. return data;
  451. }
  455. /**
  456. *功用：保存校准数据
  457. */
  458. void ADE_AdjustSaveData(void)
  459. {
  460. unsigned char i;
  461. unsigned short temp_data;
  462. unsigned short temp_add=0;
  464. ADE_WriteByte(SAVE_OK,ADE_SET_ADDR);//写入标志
  465. temp_add+=2;
  467. for(i=0;i<3;i++)
  468. {
  469. temp_data=adjusting.write_data.voltage[i];
  470. ADE_WriteByte(temp_data,ADE_SET_ADDR+temp_add);
  471. temp_add+=2;
  472. }
  474. for(i=0;i<3;i++)
  475. {
  476. temp_data=adjusting.write_data.current[i];
  477. ADE_WriteByte(temp_data,ADE_SET_ADDR+temp_add);
  478. temp_add+=2;
  479. }
  481. for(i=0;i<3;i++)
  482. {
  483. temp_data=adjusting.write_data.watt[i];
  484. ADE_WriteByte(temp_data,ADE_SET_ADDR+temp_add);
  485. temp_add+=2;
  486. }
  488. for(i=0;i<3;i++)
  489. {
  490. temp_data=adjusting.write_data.var[i];
  491. ADE_WriteByte(temp_data,ADE_SET_ADDR+temp_add);
  492. temp_add+=2;
  493. }
  495. for(i=0;i<3;i++)
  496. {
  497. temp_data=adjusting.write_data.va[i];
  498. ADE_WriteByte(temp_data,ADE_SET_ADDR+temp_add);
  499. temp_add+=2;
  500. }
  502. }
  505. /**
  506. *功用： 将缓冲区中的校准参数写入ADE7758
  507. *当确认校准参数的值后，便调用该函数，写数据写入ADE7758特定的寄存器中
  508. */
  509. void ADE_AdjustWriteValue(void)
  510. {
  511. unsigned char i;
  512. unsigned short temp_data;
  514. for(i=0;i<3;i++)
  515. {
  516. temp_data=adjusting.write_data.voltage[i];
  517. if(temp_data<0x1000)//4096
  518. ADE_Write(ADD_AVRMSGAIN+i,temp_data,16);
  519. }
  521. for(i=0;i<3;i++)
  522. {
  523. temp_data=adjusting.write_data.current[i];
  524. if(temp_data<0x1000)//4096
  525. ADE_Write(ADD_AIGAIN+i,temp_data,16);
  526. }
  528. for(i=0;i<3;i++)
  529. {
  530. temp_data=adjusting.write_data.watt[i];
  531. if(temp_data<0x1000)//4096
  532. ADE_Write(ADD_AWG+i,temp_data,16);
  533. }
  535. for(i=0;i<3;i++)
  536. {
  537. temp_data=adjusting.write_data.var[i];
  538. if(temp_data<0x1000)//4096
  539. ADE_Write(ADD_AVARG+i,temp_data,16);
  540. }
  542. for(i=0;i<3;i++)
  543. {
  544. temp_data=adjusting.write_data.va[i];
  545. if(temp_data<0x1000)//4096
  546. ADE_Write(ADD_AVAG+i,temp_data,16);
  547. }
  549. }
  553. /**
  554. *功用：读出已保存的校准参数
  555. */
  556. void ADE_AdjustReadData(void)
  557. {
  558. unsigned char i;
  559. unsigned short temp_data;
  560. unsigned short temp_add=0;
  562. if(ADE_ReadByte(ADE_SET_ADDR)==SAVE_OK)
  563. {
  564. b_adjust=1;//ADE7758现已校准标志
  565. temp_add+=2;
  567. for(i=0;i<3;i++)
  568. {
  569. temp_data=ADE_ReadByte(ADE_SET_ADDR+temp_add);
  570. adjusting.write_data.voltage[i]=temp_data;
  571. temp_add+=2;
  572. }
  574. for(i=0;i<3;i++)
  575. {
  576. temp_data=ADE_ReadByte(ADE_SET_ADDR+temp_add);
  577. adjusting.write_data.current[i]=temp_data;
  578. temp_add+=2;
  579. }
  580. for(i=0;i<3;i++)
  581. {
  582. temp_data=ADE_ReadByte(ADE_SET_ADDR+temp_add);
  583. adjusting.write_data.watt[i]=temp_data;
  584. temp_add+=2;
  585. }
  587. for(i=0;i<3;i++)
  588. {
  589. temp_data=ADE_ReadByte(ADE_SET_ADDR+temp_add);
  590. adjusting.write_data.var[i]=temp_data;
  591. temp_add+=2;
  592. }
  594. for(i=0;i<3;i++)
  595. {
  596. temp_data=ADE_ReadByte(ADE_SET_ADDR+temp_add);
  597. adjusting.write_data.va[i]=temp_data;
  598. temp_add+=2;
  599. }
  601. ADE_AdjustWriteValue();
  602. }
  604. }
  607. /**
  608. *功用：检测7758是否反常，有则修正
  609. */
  610. void ADE_Check7758(void)
  611. {
  612. unsigned short temp,temp1;
  614. if(!b_adjust)//ADE7758现已校准标志
  615. return;
  617. temp=ADE_ReadByte(ADE_SET_ADDR+2);
  618. temp1=ADE_Read(ADD_AVRMSGAIN,12)&0x0fff;
  620. if(temp!=temp1)//检测A相校准参数是否正确
  621. ADE_AdjustReadData();
  622. }
  625. /**
  626. *功用：将标志写入中止寄存器中,答应能量寄存器容量超出一半时发生中止
  627. */
  628. void ADE_WriteMask(void)
  629. {
  630. unsigned char data[3];
  631. unsigned char type;
  632. unsignedintwdata=0x00000700;//AEHF=1,VAEHF=1,低8位无用
  634. ADE_CS(0);
  636. type=ADD_MASK&0x7F;
  637. type=type|0x80;
  639. data[0]=type;
  640. ADE_SPIWrite(data,1);
  642. ADE_udelay();
  644. data[0]=(wdata>>16)&0xFF;
  645. data[1]=(wdata>>8)&0xFF;
  646. data[2]=wdata&0xFF;
  647. ADE_SPIWrite(data,3);
  649. ADE_CS(1);
  650. }
  653. /**
  654. *功用：铲除校准数据
  655. */
  656. void ADE_Clean(void)
  657. {
  658. unsigned char i;
  660. for(i=0;i<3;i++)
  661. adjusting.write_data.voltage[i]=0;
  663. for(i=0;i<3;i++)
  664. adjusting.write_data.current[i]=0;
  666. for(i=0;i<3;i++)
  667. adjusting.write_data.watt[i]=0;
  669. for(i=0;i<3;i++)
  670. adjusting.write_data.var[i]=0;
  672. for(i=0;i<3;i++)
  673. adjusting.write_data.va[i]=0;
  675. ADE_AdjustWriteValue();
  677. memset(ADE_AdjustDataBuf,0,sizeof(ADE_AdjustDataBuf));/*校验数据缓冲区清0*/
  679. }
  682. /**
  683. *功用：7758初始化函数
  684. */
  685. void ADE_Init(void)
  686. {
  687. unsigned char TempData,i;
  689. ADE_WriteMask();//write interrupt masktoade7758
  691. TempData=(0xff&ADE_Read(ADD_COMPMODE,8))|0x80;
  692. ADE_Write(ADD_COMPMODE,((int)TempData<<8),8);//seting activate the no-load threshold
  694. if(bWorkModel)
  695. {
  696. ADE_Clean();
  697. for(i=0;i<3;i++)
  698. ADE_Write(ADD_WDIV+i,0X00,8);
  699. }
  700. else//正常作业形式
  701. ADE_AdjustReadData();
  702. }
  705. intmain(void)
  706. {
  707. intret=0;
  708. ret=SPI_Open();
  709. if(ret)
  710. return ret;
  712. ADE_AdjustSaveData();
  714. ADE_Init();
  716. while(1)
  717. {
  718. sleep(1);
  719. bit_1s=1;
  720. ADE_GetData();
  721. }
  723. SPI_Close();
  724. return 0;
  725. }

声明：本文内容来自网络转载或用户投稿，文章版权归原作者和原出处所有。文中观点，不代表本站立场。若有侵权请联系本站删除（kf@86ic.com）https://www.86ic.net/ceping/baogao/275290.html
5赞
标签:

为您推荐

为什么说“AOI检测”是SMT焊接质量的把关者？

如何创建一个考虑PWM引起的交流损耗的IPM电机效率图案例

升压型DC－DC转换器中高频噪声的产生原因

速度与激情：为电动摩托车设计寿命更长的 16S-17S 锂离子电池组

可靠性测试中,如何减少HCI和电迁移的测试时间？

Tesla Roadster 开源电池监控板的学习解读

联系我们

联系我们

在线咨询: QQ交谈

邮箱: kf@86ic.com

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

返回顶部