×
嵌入式 > 技术百科 > 详情

ADE7758驱动程序

发布时间：2020-05-27 发布时间：
|
  1. /*
  2.  * ade7758.c
  3.  *
  4.  * Created on: 2014-9-12
  5.  * Author: lzy
  6.  */
  7. #include 
  8. #include "debug.h"
  9. #include "ade7758.h"
  10. #include "SpiDev.h"
  11.  
  12. unsigned char bWorkModel=0;//工作模式标志位 1：校准模式；0：正常工作模式;
  13. unsigned char bit_1s=0; //1s钟标志，在时钟中断函数中置位
  14.  
  15. static unsigned char divider = 1;//电能分频器，默认值为零，视在功率超出一定值时，自动将该值提高
  16. static unsigned int energy[9];//用于累加电能值 36
  17.  
  18. struct all_data working;//正常工作模式下存放的电参量 95
  19. struct adjust_data adjusting;//校准模式下存放的数据 65
  20.  
  21. static unsigned int vo_buffer[5][3];//用于电压的积分虑波 36
  22. static unsigned int io_buffer[5][3];//用于电流的积分虑波 36
  23.  
  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}; /*校准数据暂存缓冲区*/
  27.  
  28. void ADE_Check7758(void);
  29.  
  30. /**
  31.  * 功能：延时函数 50us
  32.  */
  33. void ADE_udelay(void)
  34. {
  35.     //    usleep(50);
  36. }
  37.  
  38. /**
  39.  * 功能：片选使能
  40.  */
  41. void ADE_CS(unsigned char cs)
  42. {
  43.     //    CSADE7758_A = cs;        //=====
  44. }
  45.  
  46.  
  47. /**
  48.  * 功能：通过SPI写入数据至芯片
  49.  * 入口参数：
  50.  *         buf -> 数据缓冲区
  51.  *         len -> 数据长度
  52.  */
  53. void ADE_SPIWrite(unsigned char *buf, unsigned char len)
  54. {
  55.     SPI_Write(buf,len);
  56. }
  57.  
  58.  
  59. /**
  60.  * 功能：通过SPI读芯片数据
  61.  * 入口参数：len -> 数据长度
  62.  * 出口参数：    buf -> 数据缓冲区
  63.  *
  64.  */
  65. void ADE_SPIRead(unsigned char *buf, unsigned char len)
  66. {
  67.     SPI_Read(buf,len);
  68. }
  69.  
  70.  
  71. /**
  72.  * 功能：7758写数据函数
  73.  * 入口参数：
  74.  * type:目标寄存器的地址
  75.  * wdata:写进寄存器的内容
  76.  * databit:目标寄存器的宽度
  77.  * 出口参数：NULL
  78.  * 返回值：NULL
  79.  */
  80. void ADE_Write(unsigned char type,unsigned int wdata,unsigned char databit)
  81. {
  82.     unsigned char data[3];
  83.  
  84.     ADE_CS(0);
  85.  
  86.     type = type | 0x80;
  87.  
  88.     data[0] = type;
  89.     ADE_SPIWrite(data, 1);
  90.     ADE_udelay();
  91.  
  92.     if(databit == 8)
  93.     {
  94.         data[0] = wdata;
  95.         ADE_SPIWrite(data, 1);
  96.     }
  97.     else if(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 ", databit);
  105.     ADE_CS(1);
  106. }
  107.  
  108. /**
  109.  * 功能：7758读寄存器函数
  110.  * 入口参数：
  111.  *          type:目标寄存器的地址
  112.  * databit:目标寄存器的宽度
  113.  * 出口参数：指定寄存器的内容
  114.  * 返回值：指定寄存器的内容
  115.  */
  116. unsigned int ADE_Read(unsigned char type,unsigned char databit)
  117. {
  118.     unsigned char data[4]={0,0,0,0};
  119.     unsigned int rtdata = 0;
  120.  
  121.     ADE_CS(0);
  122.     type = type & 0x7F;
  123.  
  124.     data[0] = type;
  125.     ADE_SPIWrite(data, 1);
  126.     ADE_udelay();
  127.  
  128.     if(databit == 8)
  129.     {
  130.         ADE_SPIRead(data,1);
  131.         rtdata = data[0];
  132.     }
  133.     else if(databit == 12)
  134.     {
  135.         ADE_SPIRead(data,2);
  136.         rtdata = (data[0]&0x0f) <
  137.         rtdata += data[1];
  138.     }
  139.     else if(databit == 16)
  140.     {
  141.         ADE_SPIRead(data,2);
  142.         rtdata = data[0] <
  143.         rtdata += data[1];
  144.     }else if(databit == 24)
  145.     {
  146.         ADE_SPIRead(data,3);
  147.         rtdata = data[0] <
  148.         rtdata += (data[1] <
  149.         rtdata += data[2];
  150.     }
  151.     else
  152.         pr_err("ADE Read databit Error:%d ", databit);
  153.     ADE_CS(1);
  154.  
  155.     return(rtdata);
  156. }
  157.  
  158. /**
  159.  * 功能：检测异常
  160.  */
  161. void ADE_AuCheck(void)
  162. {
  163.     unsigned char i;
  164.     unsigned int temp_data[5];//存放运算过程的中间变量
  165.     unsigned int temp_v,temp_i;
  166.  
  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.     }
  174.  
  175.     //自动设置分频器的大小
  176.     for( i = 0; 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.     }
  182.  
  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] ) ;
  186.  
  187.     if( divider != (char)temp_data[3] )
  188.     {
  189.         //write to ade7758
  190.         divider = (char)temp_data[3] + 1;
  191.  
  192.         for(i = 0; i 
  193.             ADE_Write( ADD_WDIV + i, ( (int) divider <
  194.     }
  195. }
  196.  
  197.  
  198. /**
  199.  * 功能：每秒读取功率
  200.  */
  201. void ADE_ReadHR(void)
  202. {
  203.     unsigned char i;
  204.     unsigned int temp_data[9];//存放运算过程的中间变量
  205.  
  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);
  218.  
  219.     for( i = 0; i 
  220.     {
  221.         if( temp_data[ i ] > 0x7fff )
  222.             temp_data[ i ] = 0xffff - temp_data[ i ] + 1;
  223.     }
  224.  
  225.     if( divider > 1)
  226.     {
  227.         for( i = 0; i 
  228.             temp_data[ i ] = temp_data[ i ] * divider;//乘上分频器的值
  229.     }
  230.  
  231.     //能量的计算
  232.     for( i = 0; i 
  233.         energy[i] += temp_data[i];//累加电能值，单位为 WS（瓦秒）
  234.  
  235.     //转换成千瓦时
  236.     for( i = 0; i 
  237.     {
  238.         working.watt_hour[i] += (energy[i] / 3600000);//转换成千瓦时
  239.         energy[i] = energy[i] % 3600000;
  240.     }
  241.  
  242.     working.watt_hour[3] = working.watt_hour[0] + working.watt_hour[1] + working.watt_hour[2];//总和
  243.  
  244.     //转换成千伏安时
  245.     for( i = 0; i 
  246.     {
  247.         working.va_hour[i] += (energy[ i+6 ] / 3600000);//转换成千瓦时
  248.         energy[ i+6 ] = energy[i+6] % 3600000;
  249.     }
  250.  
  251.     working.va_hour[3] = working.va_hour[0] + working.va_hour[1] + working.va_hour[2];//总和
  252.  
  253.     for( working.watt[ 3 ] = 0, i = 0; i 
  254.     {
  255.         working.watt[ i ] = temp_data[ i ]/1000;//千瓦
  256.         working.watt[ 3 ] += working.watt[ i ];
  257.     }
  258.  
  259.     for( working.var[ 3 ] = 0, i = 0; i 
  260.     {
  261.         working.var[ i ] = temp_data[ i +3 ]/1000;
  262.         working.var[ 3 ] += working.var[ i ];
  263.     }
  264.  
  265.     for( working.va[ 3 ] = 0, i = 0; i 
  266.     {
  267.         working.va[ i ] = temp_data[ i + 6 ] /1000;//千伏安
  268.  
  269.         if(working.va[ i ] 
  270.             working.va[ i ] = working.watt[ i ];
  271.  
  272.         working.va[ 3 ] += working.va[ i ];
  273.     }
  274.  
  275.  
  276. }
  277.  
  278. /**
  279.  * 功能：实时读取电流电压值
  280.  */
  281. void ADE_ReadVC(void)
  282. {
  283.     unsigned char i, j;
  284.  
  285.     for( i = 0; i 
  286.     {
  287.         working.voltage[ i ] = 0;
  288.         working.current[ i ] = 0;
  289.     }
  290.  
  291.     for( i = 0; i 
  292.     {
  293.         for( j = 0; j 
  294.         {
  295.             working.voltage[ i ] += vo_buffer[j][i];
  296.             working.current[ i ] += io_buffer[j][i];
  297.         }
  298.     }
  299.  
  300.     for( i = 0; i 
  301.     {
  302.         working.voltage[ i ] = working.voltage[ i ]/5;
  303.         working.current[ i ] = working.current[ i ]/5;
  304.     }
  305.  
  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;
  309.  
  310.     printf(" voltage=%d current=%d ",working.voltage[ 3 ], working.current[ 3 ]);
  311. }
  312.  
  313. /**
  314.  * 校准模式下 每秒读取功率
  315.  */
  316. void ADE_AdjustHR(void)
  317. {
  318.     unsigned char i;
  319.     unsigned int temp_data[9];//存放运算过程的中间变量
  320.  
  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);
  333.  
  334.     for( i = 0 ; 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. }
  341.  
  342.  
  343. /**
  344.  * 校准模式下实时读取电流电压值
  345.  */
  346. void ADE_AdjustVC(void)
  347. {
  348.     unsigned char i, j;
  349.  
  350.     for( i = 0; i 
  351.     {
  352.         adjusting.read_data.voltage[i] = 0;
  353.         adjusting.read_data.current[i] = 0;
  354.     }
  355.  
  356.     for( i = 0; i 
  357.     {
  358.         for( j = 0; j 
  359.         {
  360.             adjusting.read_data.voltage[i] += vo_buffer[j][i];
  361.             adjusting.read_data.current[i] += io_buffer[j][i];
  362.         }
  363.     }
  364.  
  365.     for( i = 0; 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. }
  371.  
  372.  
  373. /**
  374.  * 功能：从ADE7758中取出三相电压电流功率等电参量
  375.  */
  376. void ADE_GetData(void)
  377. {
  378.     static unsigned char bit_3s=0;
  379.     unsigned char j;
  380.  
  381.     if( !bWorkModel )    //正常工作模式
  382.     {
  383.         if( bit_1s )
  384.         {
  385.             bit_1s = 0;
  386.             ADE_ReadHR();
  387.  
  388.             if( (bit_3s++) >= 3 ) /*三秒检测一次异常*/
  389.             {
  390.                 ADE_AuCheck();
  391.                 bit_3s=0;
  392.             }
  393.         }
  394.  
  395.         for( j = 0; 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.         }
  400.  
  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.         }
  411.  
  412.         for( j = 0; 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.         }
  417.  
  418.         if( sample_cycle == 4)
  419.             ADE_AdjustVC();
  420.  
  421.  
  422.         //        save_set_to_e2prom(); //===
  423.     }
  424.  
  425.     if( sample_cycle 
  426.         sample_cycle += 1;
  427.     else
  428.         sample_cycle = 0;
  429. }
  430.  
  431.  
  432. /**
  433.  * 校准数据保存至缓冲区
  434.  */
  435. void ADE_WriteByte(unsigned short data, unsigned short addr)
  436. {
  437.     memcpy(ADE_AdjustDataBuf+addr, &data, sizeof(unsigned short));
  438. }
  439.  
  440.  
  441. /**
  442.  * 读取校准数据缓冲区中数据
  443.  */
  444. unsigned short ADE_ReadByte(unsigned short addr)
  445. {
  446.     unsigned short data;
  447.  
  448.     memcpy(&data, ADE_AdjustDataBuf+addr, sizeof(unsigned short));
  449.  
  450.     return data;
  451. }
  452.  
  453.  
  454.  
  455. /**
  456.  * 功能：保存校准数据
  457.  */
  458. void ADE_AdjustSaveData(void)
  459. {
  460.     unsigned char i;
  461.     unsigned short temp_data;
  462.     unsigned short temp_add = 0;
  463.  
  464.     ADE_WriteByte( SAVE_OK, ADE_SET_ADDR ); //写入标志
  465.     temp_add +=2;
  466.  
  467.     for(i = 0; 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.     }
  473.  
  474.     for(i = 0; 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.     }
  480.  
  481.     for(i = 0; 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.     }
  487.  
  488.     for(i = 0; 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.     }
  494.  
  495.     for(i = 0; 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.     }
  501.  
  502. }
  503.  
  504.  
  505. /**
  506.  * 功能： 将缓冲区中的校准参数写入ADE7758
  507.  * 当确定校准参数的值后，便调用该函数，写数据写入ADE7758特定的寄存器中
  508.  */
  509. void ADE_AdjustWriteValue(void)
  510. {
  511.     unsigned char i;
  512.     unsigned short temp_data;
  513.  
  514.     for(i = 0; i 
  515.     {
  516.         temp_data = adjusting.write_data.voltage[i];
  517.         if( temp_data 
  518.             ADE_Write( ADD_AVRMSGAIN + i, temp_data , 16 );
  519.     }
  520.  
  521.     for(i = 0; i 
  522.     {
  523.         temp_data = adjusting.write_data.current[i];
  524.         if( temp_data 
  525.             ADE_Write( ADD_AIGAIN + i, temp_data , 16 );
  526.     }
  527.  
  528.     for(i = 0; i 
  529.     {
  530.         temp_data = adjusting.write_data.watt[i];
  531.         if( temp_data 
  532.             ADE_Write( ADD_AWG + i, temp_data , 16 );
  533.     }
  534.  
  535.     for(i = 0; i 
  536.     {
  537.         temp_data = adjusting.write_data.var[i];
  538.         if( temp_data 
  539.             ADE_Write( ADD_AVARG + i, temp_data , 16 );
  540.     }
  541.  
  542.     for(i = 0; i 
  543.     {
  544.         temp_data = adjusting.write_data.va[i];
  545.         if( temp_data 
  546.             ADE_Write( ADD_AVAG + i, temp_data , 16 );
  547.     }
  548.  
  549. }
  550.  
  551.  
  552.  
  553. /**
  554.  * 功能：读出已保存的校准参数
  555.  */
  556. void ADE_AdjustReadData(void)
  557. {
  558.     unsigned char i;
  559.     unsigned short temp_data;
  560.     unsigned short temp_add = 0;
  561.  
  562.     if( ADE_ReadByte(ADE_SET_ADDR) == SAVE_OK)
  563.     {
  564.         b_adjust = 1;//ADE7758已经校准标志
  565.         temp_add += 2;
  566.  
  567.         for( i = 0; 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.         }
  573.  
  574.         for( i = 0; 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 
  581.         {
  582.             temp_data = ADE_ReadByte( ADE_SET_ADDR + temp_add );
  583.             adjusting.write_data.watt[i]= temp_data;
  584.             temp_add += 2;
  585.         }
  586.  
  587.         for( i = 0; 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.         }
  593.  
  594.         for( i = 0; 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.         }
  600.  
  601.         ADE_AdjustWriteValue();
  602.     }
  603.  
  604. }
  605.  
  606.  
  607. /**
  608.  * 功能：检测7758是否异常，有则修复
  609.  */
  610. void ADE_Check7758(void)
  611. {
  612.     unsigned short temp,temp1;
  613.  
  614.     if( !b_adjust )//ADE7758已经校准标志
  615.         return;
  616.  
  617.     temp = ADE_ReadByte( ADE_SET_ADDR + 2 );
  618.     temp1 = ADE_Read( ADD_AVRMSGAIN ,12 ) & 0x0fff;
  619.  
  620.     if( temp != temp1 )//检测A相校准参数是否正确
  621.         ADE_AdjustReadData();
  622. }
  623.  
  624.  
  625. /**
  626.  * 功能：将标志写入中断寄存器中,允许能量寄存器容量超出一半时产生中断
  627.  */
  628. void ADE_WriteMask(void)
  629. {
  630.     unsigned char data[3];
  631.     unsigned char type;
  632.     unsigned int wdata = 0x00000700;//AEHF=1,VAEHF=1,低8位无用
  633.  
  634.     ADE_CS(0);
  635.  
  636.     type = ADD_MASK & 0x7F;
  637.     type = type | 0x80;
  638.  
  639.     data[0] = type;
  640.     ADE_SPIWrite(data, 1);
  641.  
  642.     ADE_udelay();
  643.  
  644.     data[0] = (wdata >> 16)&0xFF;
  645.     data[1] = (wdata >> 8)&0xFF;
  646.     data[2] = wdata&0xFF;
  647.     ADE_SPIWrite(data, 3);
  648.  
  649.     ADE_CS(1);
  650. }
  651.  
  652.  
  653. /**
  654.  * 功能：清除校准数据
  655.  */
  656. void ADE_Clean(void)
  657. {
  658.     unsigned char i;
  659.  
  660.     for( i = 0; i 
  661.         adjusting.write_data.voltage[i] = 0;
  662.  
  663.     for( i = 0; i 
  664.         adjusting.write_data.current[i] = 0;
  665.  
  666.     for( i = 0; i 
  667.         adjusting.write_data.watt[i] = 0;
  668.  
  669.     for( i = 0; i 
  670.         adjusting.write_data.var[i] = 0;
  671.  
  672.     for( i = 0; i 
  673.         adjusting.write_data.va[i] = 0;
  674.  
  675.     ADE_AdjustWriteValue();
  676.  
  677.     memset(ADE_AdjustDataBuf,0,sizeof(ADE_AdjustDataBuf)); /*校验数据缓冲区清0*/
  678.  
  679. }
  680.  
  681.  
  682. /**
  683.  * 功能：7758初始化函数
  684.  */
  685. void ADE_Init(void)
  686. {
  687.     unsigned char TempData, i;
  688.  
  689.     ADE_WriteMask();//write interrupt mask to ade7758
  690.  
  691.     TempData = (0xff & ADE_Read(ADD_COMPMODE,8) ) | 0x80;
  692.     ADE_Write(ADD_COMPMODE,((int)TempData<<8),8);//seting activate the no-load threshold
  693.  
  694.     if( bWorkModel )
  695.     {
  696.         ADE_Clean();
  697.         for(i = 0; i 
  698.             ADE_Write( ADD_WDIV + i, 0X00 , 8 );
  699.     }
  700.     else    //正常工作模式
  701.         ADE_AdjustReadData();
  702. }
  703.  
  704.  
  705. int main(void)
  706. {
  707.     int ret = 0;
  708.     ret = SPI_Open();
  709.     if(ret)
  710.         return ret;
  711.  
  712.     ADE_AdjustSaveData();
  713.  
  714.     ADE_Init();
  715.  
  716.     while(1)
  717.     {
  718.         sleep(1);
  719.         bit_1s = 1;
  720.         ADE_GetData();
  721.     }
  722.  
  723.     SPI_Close();
  724.     return 0;
  725. }
 

『本文转载自网络,版权归原作者所有,如有侵权请联系删除』

上一篇:ADI 40通道DAC集成密集模拟信号处理，适合精密应用 下一篇:ADC输入阻抗信号链设计总结

相关推荐

热门文章 更多
三星研发基于risc-v架构的5G毫米波射频芯片

技术

硬件开发 EMC IC封装设计 射频RF 单片机IMCU 信号完整性 FPGA 电源 PCB设计 物联网 PCB工艺 PCBA

阅读

电子汇 最新资讯 EDA365原创吧

资源

公开课 研讨会 在线计算器

互动

论坛 外包
电巢APP下载电巢APP下载
关于我们 ｜ 手机版 ｜ EDA365电子论坛网 (粤ICP备18020198号)
GMT, 2020-03-13 09:00 , Processed in 0.109375 second(s), 13 queries , Gzip On.