标题: RN7302三相电表计量电路原理图及驱动程序源码 [打印本页]

---

作者: WH717726    时间: 2018-5-11 16:40
标题: RN7302三相电表计量电路原理图及驱动程序源码
电源控制说明：
    VCC:          由电网电源，6v电池和3.6V电池汇流提供
                    供mcu等电网掉电后需要工作的器件电源使用（此处仅用作mcu电源）。

   VSWO： 由MCU的VD（电网，6V电池，3.6V电池汇流）与mcu的VBAT（3.6V电池）汇流提供
                  供mcu的reset，8025t电源,按键等需要低功耗唤醒等位置使用。
                   1.RESET电路
                   2.8025T电源
                   3. 按键唤醒部分
                   4.上盖、端盖检测部分
    VCC_OP:  电网电源 （电池不供电）
                    供停电后不需供电的外围电路：
                    1 通讯部分： 485 、 载波、无线等
                    2 指示灯：
                    3 液晶背光：
                    4 光耦：
                    5 继电器部分：
                    6.esam可控电源。
                    7.红外发射在电网电源在线时使用vcc_op。
    VD：由电网电源和6V电池汇流而成。供给DVCC，可控的红外电源VCC_IR使用。
    DVCC:  由VD生成（选配VCC一般不采用），ctrl_dvcc=1时,dvcc=3.3V;ctrl_dvcc=0时,dvcc关断.
                    1. 计量电源
                    2. flash电源
                    需要进行计量/保存flash时打开。上电后必须使能ctrl_dvcc;掉电后在全失压检测时打开ctrl_dvcc一次
     VCC_IR:  红外收发管的电源,由ctrl_WAKE控制打开关闭.
                      打开条件： 红外唤醒
    AD_3.6V: 3.6V电池提供给mcu的Vbat。
   VDD：电网电源通过稳压得到通常=5.3V
   6V_5V:6V电池通过LDO后的电源，通常=5.0V。


电路原理图如下：




单片机源程序如下:

1. #include "RN7302_Demo.h"
   
2. 
   
3. 
   
4. __no_init   sDl645StruDataComm_TypeDef          Dl645RN7302DataComm;
   
5. __no_init   sDl645FrontTmp_TypeDef              Dl645FrontTmp;
   
6. __no_init   sDl645Front_TypeDef                 Dl645Front;
   
7. __no_init   sDl645Eg_TypeDef                    Dl645Eg;
   
8. __no_init   sDl645FirmParaFile_TypeDef          Dl645FirmPara;
   
9.             
   
10. //底层函数
    
11. u8 fnSpi2_ReadByte(void)
    
12. {
    
13.     u8 i,temp=0;
    
14.     for(i=0;i<8;i++)
    
15.     {
    
16.             temp<<=1;
    
17.             PinWrite_ADSCLK(1);
    
18.             PinWrite_ADSCLK(1);
    
19.             fnDelay2us();
    
20.             fnDelay2us();
    
21.             fnDelay2us();
    
22.             fnDelay2us();
    
23.             PinWrite_ADSCLK(0);
    
24.             PinWrite_ADSCLK(0);
    
25.             fnDelay2us();
    
26.             fnDelay2us();
    
27.             fnDelay2us();
    
28.             fnDelay2us();
    
29.             if (PinRead_ADSDI()){temp=temp+0x1;}
    
30.             fnDelay2us();
    
31.             fnDelay2us();
    
32.             fnDelay2us();
    
33.     }
    
34.     return        temp;
    
35. }
    
36. //////////////////////////////////////////////////////////////////////////
    
37. 
    
38. 
    
39. void fnSpi2_WriteByte(u8 Dat)
    
40. {
    
41.     u8 i;
    
42. 
    
43.     for(i=0;i<8;i++)
    
44.     {
    
45.             PinWrite_ADSCLK(1);
    
46.             PinWrite_ADSCLK(1);
    
47.             fnDelay2us();
    
48.             fnDelay2us();
    
49.             if(Dat & 0x80)
    
50.             {
    
51.                     PinWrite_ADSDO(1);
    
52.                     PinWrite_ADSDO(1);
    
53.                     fnDelay2us();
    
54.                     fnDelay2us();
    
55.                     fnDelay2us();
    
56.             }
    
57.             else
    
58.             {
    
59.                     PinWrite_ADSDO(0);
    
60.                     PinWrite_ADSDO(0);
    
61.                     fnDelay2us();
    
62.                     fnDelay2us();
    
63.                     fnDelay2us();
    
64.             }
    
65.             PinWrite_ADSCLK(0);
    
66.             PinWrite_ADSCLK(0);
    
67.             fnDelay2us();
    
68.             fnDelay2us();
    
69.             fnDelay2us();
    
70.             Dat <<= 1;
    
71.     }
    
72.     PinWrite_ADSDO(1);
    
73.     PinWrite_ADSDO(1);
    
74.     fnDelay2us();
    
75.     fnDelay2us();
    
76.     fnDelay2us();
    
77. }
    
78. 
    
79. //存储器写入函数
    
80. ErrorStatus fnMemory_Write(u32 Dst , u8 *Src , u32 DatLen)
    
81. {
    
82.     ErrorStatus err;
    
83. 
    
84.     if( (FM24C_START_ADDR <= Dst) &&
    
85.             ( (Dst + DatLen) < (FM24C_START_ADDR + FM24C_SIZE) ) )
    
86.     {               
    
87.             #if  !DL645SOFT_DEBUG        
    
88.             err = fnFM24CXX_Write(Dst- FM24C_START_ADDR , Src  , DatLen , 3);
    
89.             if(err==ERROR) Dl645Bkgrd.PubData.EventErr[5]=BKGRD_EVENTERR_INTERMEMORY;
    
90.             else Dl645Bkgrd.PubData.EventErr[5]=BKGRD_EVENTERR_OK;
    
91.             #endif
    
92.     }
    
93. 
    
94.     else if( (AT45DB_START_ADDR <= Dst) &&
    
95.             ( (Dst + DatLen) < (AT45DB_START_ADDR + AT45DB_SIZE) ) )
    
96.     {               
    
97.             #if  !DL645SOFT_DEBUG
    
98.             err = fnAT45DBXX_Write( Dst - AT45DB_START_ADDR , Src , DatLen , 3);
    
99.             if(err==ERROR) Dl645Bkgrd.PubData.EventErr[5]=BKGRD_EVENTERR_INTERMEMORY;
    
100.             else Dl645Bkgrd.PubData.EventErr[5]=BKGRD_EVENTERR_OK;
     
101.             #endif
     
102.     }
     
103. 
     
104.     else
     
105.     {        
     
106.             err = ERROR;
     
107.             Dl645Bkgrd.PubData.EventErr[5]=BKGRD_EVENTERR_INTERMEMORY;
     
108.     }
     
109. 
     
110.     return(err);        
     
111. }
     
112. //存储器读取函数
     
113. ErrorStatus fnMemory_Read(u8 *Dst , u32 Src , u32 DatLen)
     
114. {
     
115.     ErrorStatus err;
     
116.     if( (FM24C_START_ADDR <= Src) &&
     
117.             ( (Src + DatLen) < (FM24C_START_ADDR + FM24C_SIZE) ) )
     
118.     {               
     
119.             #if  !DL645SOFT_DEBUG        
     
120.             err = fnFM24CXX_Read(Dst , Src - FM24C_START_ADDR , DatLen , 3);
     
121.             if(err==ERROR) Dl645Bkgrd.PubData.EventErr[5]=BKGRD_EVENTERR_INTERMEMORY;
     
122.             else Dl645Bkgrd.PubData.EventErr[5]=BKGRD_EVENTERR_OK;
     
123.             #endif
     
124.     }        
     
125. 
     
126.     else if( (AT45DB_START_ADDR <= Src) &&
     
127.             ( (Src + DatLen) < (AT45DB_START_ADDR + AT45DB_SIZE) ) )
     
128.     {        
     
129.             #if  !DL645SOFT_DEBUG
     
130.             err = fnAT45DBXX_Read(Dst , Src - AT45DB_START_ADDR , DatLen , 3);
     
131.             if(err==ERROR) Dl645Bkgrd.PubData.EventErr[5]=BKGRD_EVENTERR_INTERMEMORY;
     
132.             else Dl645Bkgrd.PubData.EventErr[5]=BKGRD_EVENTERR_OK;
     
133.             #endif
     
134.     }
     
135. 
     
136.     else
     
137.     {        
     
138.             err = ERROR;
     
139.     }
     
140. 
     
141.     return(err);
     
142. }
     
143. 
     
144. 
     
145.    
     
146. // 文件操作函数
     
147. ErrorStatus fnDl645File_Read(u8 FileId , u32 OffAddr , void *Dst , u32 Len)
     
148. {
     
149.     if(FileId >= Dl645FileId_Max) return(ERROR);
     
150.     if( (OffAddr + Len) > Dl645FileInfo[FileId].Len) return(ERROR);        
     
151.     return(fnMemory_Read(Dst , Dl645FileInfo[FileId].StartAddr + OffAddr , Len) );
     
152. }
     
153. 
     
154. ErrorStatus fnDl645File_Write(u8 FileId , u32 OffAddr , void *Src , u32 Len)
     
155. {
     
156.     if(FileId >= Dl645FileId_Max) return(ERROR);
     
157.     if( (OffAddr + Len) > Dl645FileInfo[FileId].Len) return(ERROR);        
     
158.     return(fnMemory_Write(Dl645FileInfo[FileId].StartAddr + OffAddr , Src , Len) );        
     
159. }
     
160. 
     
161. 
     
162. 
     
163. 
     
164. ErrorStatus fnRN7302_Write(u16 wReg,u8 *pBuf,u8 DatLen)
     
165. {
     
166.     u8 i,temp,chksum,Repeat;
     
167.     ErrorStatus        err = SUCCESS;
     
168.     if( (DatLen == 0) || (DatLen > 4) ) return(ERROR);
     
169.     for( Repeat =3; Repeat != 0 ; Repeat--)               
     
170.     {
     
171.             PinWrite_ADCS(0);
     
172.             NOP();
     
173.             temp = (u8)(wReg & 0x00ff);
     
174.             chksum = temp;
     
175.             fnSpi2_WriteByte( temp); //first write hight Addr
     
176.             temp = (((u8)(wReg >> 4)) & 0xf0) + 0x80;
     
177.             chksum += temp;
     
178.             fnSpi2_WriteByte( temp);
     
179.             
     
180.             for(i = DatLen; i > 0;i-- )
     
181.             {
     
182.                     fnSpi2_WriteByte(pBuf[i-1]);  // first write high data
     
183.                     chksum +=pBuf[i-1];
     
184.             }
     
185.             chksum = ~chksum;
     
186.             fnSpi2_WriteByte(chksum);
     
187.         //                PinWrite_ADCS(1);
     
188.         //                NOP();
     
189.         //读WData寄存器检查-----------------------
     
190.         //                PinWrite_ADCS(0);        
     
191.         //                NOP();
     
192.                
     
193.             fnSpi2_WriteByte( 0x8D);
     
194.             chksum = 0x8D;
     
195.             temp =  ( (u8)(0x018D >> 4) & 0xf0);                        
     
196.             fnSpi2_WriteByte( temp );
     
197.             chksum += temp;
     
198.             for(i = 3 ; i > 0 ; i--)
     
199.             {
     
200.                     temp = fnSpi2_ReadByte();
     
201.                     if(DatLen >= i)
     
202.                     {                                       
     
203.                             if(temp != pBuf[i - 1])
     
204.                             {
     
205.                                     err = ERROR;
     
206.                                     break;        
     
207.                             }        
     
208.                     }
     
209.                     chksum += temp;
     
210.             }
     
211.             if(err == SUCCESS)
     
212.         {
     
213.             chksum = ~chksum;
     
214.             temp = fnSpi2_ReadByte();   
     
215.                     if(temp != chksum)  err = ERROR;
     
216.                }
     
217.             
     
218.             PinWrite_ADCS(1);
     
219.             if(err == SUCCESS) break;
     
220.             fnDelay2us();
     
221.             fnDelay2us();
     
222.     }
     
223.     PinWrite_ADSDO(1);
     
224.     PinWrite_ADSCLK(1);
     
225.     return(err);        
     
226. }
     
227. 
     
228. ErrorStatus fnRN7302_Read(u16 wReg,u8 *pBuf,u8 DatLen)
     
229. {
     
230.     u8 i,temp,chksum,Repeat;
     
231.     ErrorStatus        err = SUCCESS;
     
232.     if(DatLen == 0) return(ERROR);
     
233.     for( Repeat=3; Repeat != 0 ; Repeat--)               
     
234.     {
     
235.             PinWrite_ADCS(0);
     
236.             fnDelay2us();
     
237.             temp = (u8)(wReg & 0x00ff);
     
238.             chksum = temp;
     
239.             fnSpi2_WriteByte( temp); //first write hight Addr
     
240.             temp = ((u8)(wReg >> 4))& 0xf0;
     
241.             chksum += temp;
     
242.             fnSpi2_WriteByte( temp);
     
243.         
     
244.             for(i = DatLen; i > 0;i--)
     
245.             {
     
246.                     pBuf[i-1] = fnSpi2_ReadByte();
     
247.                     chksum += pBuf[i-1];
     
248.             }
     
249.             chksum = ~chksum;
     
250.             if(fnSpi2_ReadByte()!=chksum)  err = ERROR;
     
251.         //                PinWrite_ADCS(1);
     
252.         //---读RData寄存器检查------------------------------------
     
253.             if(err != SUCCESS) continue;
     
254.             
     
255.             fnSpi2_WriteByte( 0x8c);//读上一次SPI 读出的数据
     
256.             chksum = 0x8c;
     
257.             temp =  ( (u8)(0x018C >> 4) & 0xf0);                        
     
258.             fnSpi2_WriteByte( temp );
     
259.             chksum += temp;
     
260.             for(i = 4 ; i > 0 ; i--)
     
261.             {
     
262.                     temp = fnSpi2_ReadByte();
     
263.                     if(DatLen >= i)
     
264.                     {                                       
     
265.                             if(temp != pBuf[i - 1])
     
266.                             {
     
267.                                     err = ERROR;
     
268.                                     break;        
     
269.                             }        
     
270.                     }
     
271.                     chksum += temp;
     
272.             }
     
273.             if(err == SUCCESS)
     
274.         {
     
275.             chksum = ~chksum;
     
276.             temp = fnSpi2_ReadByte();   
     
277.                     if(temp != chksum)  err = ERROR;
     
278.                }
     
279.             
     
280.             PinWrite_ADCS(1);
     
281.             if(err == SUCCESS) break;        
     
282.             fnDelay2us();
     
283.             fnDelay2us();
     
284.     }
     
285.     PinWrite_ADCS(1);
     
286.     PinWrite_ADSDO(1);
     
287.     PinWrite_ADSCLK(1);
     
288.     return(err);
     
289. }
     
290. 
     
291. void fnRN7302_Init(void)
     
292. {
     
293.     Dl645RN7302DataComm.ucTemp8 = 0xe5; // 写使能位
     
294.     fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
     
295.    
     
296.     Dl645RN7302DataComm.ucTemp8 = 0xA2; // 切换到EMM模式
     
297.     fnRN7302_Write(WMSW,Dl645RN7302DataComm.ucTempBuf,1);
     
298.    
     
299.     Dl645RN7302DataComm.ucTemp8 = 0xfa; // 写使能位
     
300.     fnRN7302_Write(0x0182,Dl645RN7302DataComm.ucTempBuf,1);
     
301.     SystemDelay(10);
     
302.     Dl645RN7302DataComm.ucTemp8 = 0xe5; // 写使能位
     
303.     fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
     
304.    
     
305.     Dl645RN7302DataComm.ucTemp8 = 0xA2; // 切换到EMM模式
     
306.     fnRN7302_Write(WMSW,Dl645RN7302DataComm.ucTempBuf,1);
     
307.    
     
308.     Dl645RN7302DataComm.ucTempBuf[0] = 0x77; // 计量控制位
     
309.     Dl645RN7302DataComm.ucTempBuf[1] = 0x77;
     
310.     Dl645RN7302DataComm.ucTempBuf[2] = 0x77;
     
311.     fnRN7302_Write(0x0162,Dl645RN7302DataComm.ucTempBuf,3);
     
312.    
     
313.     Dl645RN7302DataComm.wTemp16 = Dl645FirmPara.HFConst1;
     
314.     fnRN7302_Write(HFCONST1,Dl645RN7302DataComm.ucTempBuf,2);
     
315.    
     
316.     // 电压增益初始化
     
317.     fnRN7302_Write(GSUA,(u8 *)&Dl645FirmPara.VGain[0],2);
     
318.     fnRN7302_Write(GSUB,(u8 *)&Dl645FirmPara.VGain[1],2);
     
319.     fnRN7302_Write(GSUC,(u8 *)&Dl645FirmPara.VGain[2],2);
     
320.    
     
321.     // 电流增益初始化
     
322.     fnRN7302_Write(GSIA,(u8 *)&Dl645FirmPara.IGain[0],2);
     
323.     fnRN7302_Write(GSIB,(u8 *)&Dl645FirmPara.IGain[1],2);
     
324.     fnRN7302_Write(GSIC,(u8 *)&Dl645FirmPara.IGain[2],2);
     
325.     fnRN7302_Write(GSIN,(u8 *)&Dl645FirmPara.IGain[3],2);
     
326.    
     
327.     // 通道相位校正
     
328.     fnRN7302_Write(PRTH1L,(u8 *)&Dl645FirmPara.PRth[0],2);
     
329.     fnRN7302_Write(PRTH1H,(u8 *)&Dl645FirmPara.PRth[1],2);
     
330.     fnRN7302_Write(PRTH2L,(u8 *)&Dl645FirmPara.PRth[2],2);
     
331.     fnRN7302_Write(PRTH2H,(u8 *)&Dl645FirmPara.PRth[3],2);  // 通道相位分段参数
     
332.    
     
333.    
     
334.     // 通道相位校正
     
335.     fnRN7302_Write(PHSIA,(u8 *)&Dl645FirmPara.PHSI[0],3);
     
336.     fnRN7302_Write(PHSIB,(u8 *)&Dl645FirmPara.PHSI[1],3);
     
337.     fnRN7302_Write(PHSIC,(u8 *)&Dl645FirmPara.PHSI[2],3);
     
338.    
     
339.     fnRN7302_Write(PA_PHS,(u8 *)&Dl645FirmPara.P_PHS[0],2);
     
340.     fnRN7302_Write(PB_PHS,(u8 *)&Dl645FirmPara.P_PHS[1],2);
     
341.     fnRN7302_Write(PC_PHS,(u8 *)&Dl645FirmPara.P_PHS[2],2);
     
342.    
     
343.     fnRN7302_Write(GPA,(u8 *)&Dl645FirmPara.PGain[0],2);
     
344.     fnRN7302_Write(GPB,(u8 *)&Dl645FirmPara.PGain[1],2);
     
345.     fnRN7302_Write(GPC,(u8 *)&Dl645FirmPara.PGain[2],2);
     
346.    
     
347.     fnRN7302_Write(GQA,(u8 *)&Dl645FirmPara.PGain[0],2);
     
348.     fnRN7302_Write(GQB,(u8 *)&Dl645FirmPara.PGain[1],2);
     
349.     fnRN7302_Write(GQC,(u8 *)&Dl645FirmPara.PGain[2],2);
     
350.    
     
351.     fnRN7302_Write(GSA,(u8 *)&Dl645FirmPara.PGain[0],2);
     
352.     fnRN7302_Write(GSB,(u8 *)&Dl645FirmPara.PGain[1],2);
     
353.     fnRN7302_Write(GSC,(u8 *)&Dl645FirmPara.PGain[2],2);
     
354.    
     
355.     // 通道功率OFFSET校正
     
356.     fnRN7302_Write(PA_OS,(u8 *)&Dl645FirmPara.UI_Offset[0],2);
     
357.     fnRN7302_Write(PB_OS,(u8 *)&Dl645FirmPara.UI_Offset[1],2);
     
358.     fnRN7302_Write(PC_OS,(u8 *)&Dl645FirmPara.UI_Offset[2],2);
     
359.    
     
360.     fnRN7302_Write(IStart_PS,(u8 *)&Dl645FirmPara.NOLOAD,2);
     
361.     fnRN7302_Write(ZXOT,(u8 *)&Dl645FirmPara.ZEROSTAR,2);
     
362.    
     
363.     Dl645RN7302DataComm.ucTemp8 = 0x42;
     
364.     fnRN7302_Write(0x0184,Dl645RN7302DataComm.ucTempBuf,1);
     
365.     Dl645RN7302DataComm.ucTemp8 = 0;   
     
366.     fnRN7302_Write(0x0185,Dl645RN7302DataComm.ucTempBuf,1);
     
367.     Dl645RN7302DataComm.ucTemp8 = 0;
     
368.     fnRN7302_Write(0x0184,Dl645RN7302DataComm.ucTempBuf,1);
     
369.    
     
370.     Dl645RN7302DataComm.ucTempBuf[0] = 0x10;
     
371.     Dl645RN7302DataComm.ucTempBuf[1] = 0x32;
     
372.     Dl645RN7302DataComm.ucTempBuf[2] = 0x07;
     
373.     fnRN7302_Write(CFCFG,Dl645RN7302DataComm.ucTempBuf,3);
     
374.     Dl645RN7302DataComm.ucTempBuf[0] = 0x40; // 计量控制位 默认值 400000
     
375.     Dl645RN7302DataComm.ucTempBuf[1] = 0x00;
     
376.     Dl645RN7302DataComm.ucTempBuf[2] = 0x00;
     
377.     fnRN7302_Write(0x0161,Dl645RN7302DataComm.ucTempBuf,3);
     
378.    
     
379.    
     
380.     Dl645RN7302DataComm.ucTemp8 = 0x10; // 清空采样数据缓存区
     
381.     fnRN7302_Write(0x0163,Dl645RN7302DataComm.ucTempBuf,1);
     
382.    
     
383.     Dl645RN7302DataComm.ucTemp8 = 0xDC; // 写保护
     
384.     fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
     
385.     Dl645FirmPara.FractionP=0x04;
     
386.     Dl645FirmPara.FractionI=0x04;
     
387.     Dl645FirmPara.FractionU=0x02;
     
388. }
     
389. 
     
390. void fnDl645Front_Exec(void)
     
391. {
     
392.     //读电压电流
     
393.     for(i=0;i<4;i++)
     
394.     {
     
395.         Dl645FrontTmp.UI[i] = 0 ;
     
396.         fnRN7302_Read( 0x000b+i , (u8 *)&Dl645FrontTmp.UI[i] , 4 ) ;
     
397.         
     
398.     }
     
399.     for(i=0;i<3;i++)
     
400.     {
     
401.         Dl645FrontTmp.UI[i+4] = 0 ;
     
402.         fnRN7302_Read( 0x0007+i , (u8 *)&Dl645FrontTmp.UI[i+4] , 4 ) ;
     
403.         
     
404.     }
     
405.    
     
406.     //读功率
     
407.     for(i=0;i<12;i++)
     
408.     {
     
409.         Dl645FrontTmp.Pw[i] = 0 ;
     
410.         fnRN7302_Read(0x0014+i,(u8 *)&Dl645FrontTmp.Pw[i],4);
     
411.         if((Dl645FrontTmp.Pw[i]<30)&&(Dl645FrontTmp.Pw[i]>-30))
     
412.         Dl645FrontTmp.Pw[i]=0;
     
413.     }
     
414.    
     
415. 
     
416.     //读功率方向
     
417.     fnRN7302_Read(PQSign,(u8 *)&Dl645FrontTmp.PDirect,2);
     
418.    
     
419.     //读电压电流角度值
     
420.     for(i=0;i<5;i++)
     
421.     {
     
422.         Dl645FrontTmp.Angle[i] = 0 ;
     
423.         fnRN7302_Read(YUB+i,(u8 *)&Dl645FrontTmp.Angle[i],3);
     
424.         Dl645Front.PubData.Angle[i] = fnHexToBcd_u16((u16)(((float)Dl645FrontTmp.Angle[i]/16777216)*3600));
     
425.     }
     
426.    
     
427.     //功率计算
     
428.     for(j=0;j<3;j++)
     
429.     {
     
430.         
     
431.         for(i=0;i<3;i++)
     
432.         {
     
433.             Dl645Front.PubData.Pw[j*4+i+1]=fnDFConver_Hex32ToDF09((s32)((Dl645FrontTmp.Pw[j*4+i])/((Dl645FirmPara.PRmsConst))));//计算｛Pa Pb Pc｝、｛Qa Qb Qc｝、｛Sa Sb Sc｝
     
434.         }
     
435.     }
     
436.     Tempw = (s32)((Dl645FrontTmp.Pw[3])/((Dl645FirmPara.PRmsConst))) ;
     
437.     Dl645Front.PubData.Pw[0]=fnDFConver_Hex32ToDF09(Tempw);
     
438.     Tempq = (s32)((Dl645FrontTmp.Pw[7])/((Dl645FirmPara.PRmsConst))) ;
     
439.     Dl645Front.PubData.Pw[4]=fnDFConver_Hex32ToDF09(Tempq);
     
440.     // 计算总视在功率
     
441.     Tempws = (s32)sqrt((float)Tempw*(float)Tempw+(float)Tempq*(float)Tempq);
     
442.     Dl645Front.PubData.Pw[8] = fnDFConver_Hex32ToDF09(Tempws);//计算P、Q
     
443.    
     
444.     //功率因数计算
     
445.     //总功率因数
     
446.     Dl645Front.PubData.Pf[0]=fnDFConver_Bcd16To16((s16)((1000*(double)(Tempw))/(Tempws)));
     
447.    
     
448.     //电压电流计算
     
449.     for(i=0;i<3;i++)
     
450.     {
     
451.         Dl645Front.PubData.U[i]=0x7fff&(fnDFConver_Bcd16To16((s16)(Dl645FrontTmp.UI[i+4]/(10*(Dl645FirmPara.VRmsConst))))); //电压
     
452.     }
     
453.    
     
454.    
     
455.     TempIa = (s32)(Dl645FrontTmp.UI[0]/(Dl645FirmPara.IRmsConst));
     
456.     TempIb = (s32)(Dl645FrontTmp.UI[1]/(Dl645FirmPara.IRmsConst));
     
457.     TempIc = (s32)(Dl645FrontTmp.UI[2]/(Dl645FirmPara.IRmsConst));
     
458.     Dl645Front.PubData.I[0] = fnDFConver_Bcd32To32(TempIa);
     
459.     Dl645Front.PubData.I[1] = fnDFConver_Bcd32To32(TempIb);
     
460.     Dl645Front.PubData.I[2] = fnDFConver_Bcd32To32(TempIc);
     
461.     Dl645Front.PubData.I[3] = fnDFConver_Bcd32To32((s32)(Dl645FrontTmp.UI[3]/(Dl645FirmPara.IRmsConst)));
     
462. 
     
463.     if(Dl645FrontTmp.PDirect&0x0001) Dl645Front.PubData.I[0] |= 0x80000000;
     
464.     if(Dl645FrontTmp.PDirect&0x0002) Dl645Front.PubData.I[1] |= 0x80000000;
     
465.     if(Dl645FrontTmp.PDirect&0x0004) Dl645Front.PubData.I[2] |= 0x80000000;   
     
466. 
     
467.    
     
468.     //频率计算
     
469.     if((Dl645FrontTmp.Frequency>1638400)||(Dl645FrontTmp.Frequency<1092266))  //when 50HZ is 5120 ;+- 20% frequence is 6144 and 4096
     
470.         Dl645FrontTmp.Frequency=1310720;
     
471.     Dl645Front.PubData.Frequency=fnHexToBcd_u16((u16)(65536000/(Dl645FrontTmp.Frequency/100)));
     
472.    
     
473.     //转换功率方向
     
474.     Dl645Front.PubData.PDirect = ( (Dl645FrontTmp.PDirect << 1) & 0xee) | ( (Dl645FrontTmp.PDirect >> 3) & 0x11);
     
475. 
     
476.    
     
477.     if(Dl645Bkgrd.PriPara.WireMode==0x01)   //三相三线
     
478.     {
     
479.         Dl645Front.PubData.Angle[3]=0;
     
480.         Dl645Front.PubData.Angle[6]=0;
     
481.     }
     
482.    
     
483.    
     
484.     //从RN8302读出的即为脉冲数//{P,Q,Ps},{Pa,Qa,Psa},{Pb,Qb,Psb},{Pc,Qc,Psc}{Fp,Fq}{Fpa,Fqa}{Fpb,Fqb}{Fpc,Fqc}
     
485.     /*读电能寄存器*/
     
486.     for(i=0;i<3;i++)
     
487.     {
     
488.         Dl645FrontTmp.Pulse[(i+1)*3] = 0;
     
489.         fnRN7302_Read(EPA+i,(u8 *)&Dl645FrontTmp.Pulse[(i+1)*3],3);   //有功
     
490.         Dl645FrontTmp.Pulse[(i+1)*3+1] = 0;
     
491.         fnRN7302_Read(EQA+i,(u8 *)&Dl645FrontTmp.Pulse[(i+1)*3+1],3);  //无功
     
492.         Dl645FrontTmp.Pulse[(i+1)*3+2] = 0;
     
493.         fnRN7302_Read(ESA+i,(u8 *)&Dl645FrontTmp.Pulse[(i+1)*3+2],3);   //视在有功
     
494.         Dl645FrontTmp.Pulse[14+i*2] =0;
     
495.         fnRN7302_Read(FEPA+i,(u8 *)&Dl645FrontTmp.Pulse[14+i*2],3);      //基波有功
     
496.         Dl645FrontTmp.Pulse[15+i*2] = 0;
     
497.         fnRN7302_Read(FEQA+i,(u8 *)&Dl645FrontTmp.Pulse[15+i*2],3);      //基波无功
     
498.     }
     
499.     Dl645FrontTmp.Pulse[0] = 0;
     
500.     fnRN7302_Read(EPT,(u8 *)&Dl645FrontTmp.Pulse[0],3);         //总有功
     
501.     Dl645FrontTmp.Pulse[1] = 0;
     
502.     fnRN7302_Read(EQT,(u8 *)&Dl645FrontTmp.Pulse[1],3);         //总无功
     
503.     Dl645FrontTmp.Pulse[2] = 0;
     
504.     fnRN7302_Read(EST,(u8 *)&Dl645FrontTmp.Pulse[2],3);         //总视在
     
505.     Dl645FrontTmp.Pulse[12] =0;
     
506.     fnRN7302_Read(FEPT,(u8 *)&Dl645FrontTmp.Pulse[12],3);      //总基波有功
     
507.     Dl645FrontTmp.Pulse[13] =0;
     
508.     fnRN7302_Read(FEQT,(u8 *)&Dl645FrontTmp.Pulse[13],3);      //总基波无功
     
509.    
     
510. 
     
511.     for(i=0;i<20;i++)//电能高频脉冲转换成低频脉冲
     
512.     {
     
513.         Dl645FrontTmp.Pulse_Eg[i]+=Dl645FrontTmp.Pulse[i];
     
514.     }
     
515. }
     
516. 
     
517. void fnDl645Energy_Exec(void)
     
518. {
     
519.     u8 Ep[20];
     
520.     if( !(Dl645FrontTmp.Pulse_Eg[0] | Dl645FrontTmp.Pulse_Eg[1] | Dl645FrontTmp.Pulse_Eg[2] | Dl645FrontTmp.Pulse_Eg[3] |
     
521.         Dl645FrontTmp.Pulse_Eg[4] | Dl645FrontTmp.Pulse_Eg[5] | Dl645FrontTmp.Pulse_Eg[6] | Dl645FrontTmp.Pulse_Eg[7] |
     
522.         Dl645FrontTmp.Pulse_Eg[8] | Dl645FrontTmp.Pulse_Eg[9] | Dl645FrontTmp.Pulse_Eg[10] | Dl645FrontTmp.Pulse_Eg[11] |
     
523.         Dl645Eg.PubPara.fMinute) )
     
524.     {
     
525.         return;
     
526. 
     
527.     }
     
528.     //Dl645Eg.PubPara.PPlsDeltaE为脉冲数，如脉冲数为800，因电能小数为2位，故此值为8
     
529.     for(i = 0 ; i < 12 ; i++)
     
530.     {
     
531.             Ep[i] = 0;
     
532.             
     
533.             if(Dl645FrontTmp.Pulse_Eg[i])
     
534.             {
     
535.                     Dl645Eg.PriData.PieceEg[i] += Dl645FrontTmp.Pulse_Eg[i];
     
536.                     Dl645FrontTmp.Pulse_Eg[i] = 0;
     
537.                     
     
538.                     switch(i % 3)
     
539.                     {
     
540.                     case 0:
     
541.                             if(Dl645Eg.PubPara.PPlsDeltaE == 0) break;                                
     
542.                             while (Dl645Eg.PriData.PieceEg[i] >= Dl645Eg.PubPara.PPlsDeltaE)//需按电能小数位数进行计算
     
543.                           {
     
544.                                   Ep[i]++;
     
545.                                   Dl645Eg.PriData.PieceEg[i] -= Dl645Eg.PubPara.PPlsDeltaE;
     
546.                           }
     
547.                             break;
     
548.                     case 1:
     
549.                             if(Dl645Eg.PubPara.QPlsDeltaE == 0) break;
     
550.                             while (Dl645Eg.PriData.PieceEg[i] >= Dl645Eg.PubPara.QPlsDeltaE)//需按电能小数位数进行计算
     
551.                           {
     
552.                                   Ep[i]++;
     
553.                                   Dl645Eg.PriData.PieceEg[i] -= Dl645Eg.PubPara.QPlsDeltaE;
     
554.                           }
     
555.                             break;
     
556.                     default:
     
557.                             if(Dl645Eg.PubPara.PsPlsDeltaE == 0) break;
     
558.                             while (Dl645Eg.PriData.PieceEg[i] >= Dl645Eg.PubPara.PsPlsDeltaE)//需按电能小数位数进行计算
     
559.                           {
     
560.                                   Ep[i]++;
     
561.                                   Dl645Eg.PriData.PieceEg[i] -= Dl645Eg.PubPara.PsPlsDeltaE;
     
562.                           }
     
563.                             break;        
     
564.                     }
     
565.             }        
     
566.     }
     
567. 
     
568.     for(i = 0 ; i < 8 ; i++)
     
569.     {
     
570.             Ep[i+12] = 0;
     
571.             
     
572.             if(Dl645FrontTmp.Pulse_Eg[i+12])
     
573.             {
     
574.                     Dl645Eg.PriData.PieceEg[i+12] += Dl645FrontTmp.Pulse_Eg[i+12];
     
575.                     Dl645FrontTmp.Pulse_Eg[i+12] = 0;
     
576.                     
     
577.                     switch((i+12) % 2)
     
578.                     {
     
579.                     case 0:
     
580.                             if(Dl645Eg.PubPara.PPlsDeltaE == 0) break;                                
     
581.                             while (Dl645Eg.PriData.PieceEg[i+12] >= Dl645Eg.PubPara.PPlsDeltaE)//需按电能小数位数进行计算
     
582.                           {
     
583.                                   Ep[i+12]++;
     
584.                                   Dl645Eg.PriData.PieceEg[i+12] -= Dl645Eg.PubPara.PPlsDeltaE;
     
585.                           }
     
586.                             break;
     
587.                     default :
     
588.                             if(Dl645Eg.PubPara.QPlsDeltaE == 0) break;
     
589.                             while (Dl645Eg.PriData.PieceEg[i+12] >= Dl645Eg.PubPara.QPlsDeltaE)//需按电能小数位数进行计算
     
590.                           {
     
591.                                   Ep[i+12]++;
     
592.                                   Dl645Eg.PriData.PieceEg[i+12] -= Dl645Eg.PubPara.QPlsDeltaE;
     
593.                           }
     
594.                             break;
     
595.                     }
     
596.             }        
     
597.     }
     
598. }
     
599. 
     
600. 
     
601. // RxFrm为通讯数据指针，指到07协议的第1个68数据，为sFrmDl645B_TypeDef类型指针
     
602. //校表进行增益校准和相位校准，可选择进行相位分段校准
     
603. // 校表部分程序
     
604. eDL645B_ErrInfo_TypeDef fnDl645_PutParaVar(sFrmDl645B_TypeDef *RxFrm)
     
605. {
     
606.         u8  i,j,k;
     
607.         u32 DITemp=0x0;
     
608.     u8  UnConst[6],InConst[6],ImaxConst[6];        
     
609.         u16 nItem,tempconst,tempub,tempib;
     
610.         u16        temphfconst;
     
611.         u32 tempus,tempis;
     
612.         sDF10        ConstE;
     
613.         ErrorStatus err;
     
614.         u16 tempuc=0,tempud=0;
     
615.         u32 tempic=0,tempid=0;               
     
616.         float ADErr;
     
617.         u32        temppw[2];
     
618.         i=RxFrm->UDat.DI3;
     
619.         RxFrm->UDat.DI3=0;
     
620.         memcpy(&DITemp , &RxFrm->UDat.DI0 , 4);
     
621.         RxFrm->UDat.DI3=i;
     
622.         
     
623.         if((DITemp==0xFE0001)||(DITemp==0xFE0002)||(DITemp==0xFE0003))
     
624.         {
     
625.                 if(RxFrm->Len != (12 + 5*sizeof(u16) ) ) return(DL645B_ERRINFO_DATA);        
     
626.             fnDl645File_Write(Dl645FileId_GeneralPara , Dl645FileItemInfoOffAddr_GeneralPara_OutputPara + 16 + (5*sizeof(u16)) * (RxFrm->UDat.DI0 - 1) , &RxFrm->UDat.Dat[8] , 5*sizeof(u16) );
     
627.                 memset(&Dl645Output.PriPara,0,sizeof(Dl645Output.PriPara) - 2);
     
628.                 return(DL645B_ERRINFO_OK);
     
629.     }
     
630.         if(DITemp==0x00f91201)
     
631.         {
     
632.                 if((RxFrm->UDat.Dat[0] == 0x03)&&(RxFrm->UDat.Dat[1] == 0x43)&&(RxFrm->UDat.Dat[2] == 0x56)&&(RxFrm->UDat.Dat[3] == 0x98)) ;
     
633.                 else return(DL645B_ERRINFO_PSW);
     
634.         }
     
635.         else if(DITemp==0x001503) ;
     
636.         else
     
637.         {
     
638.                 if(!(Dl645Bkgrd.PubData.MtSta.MtSta3.StaBit.PrgEnable) ) return(DL645B_ERRINFO_PSW);         
     
639.                 err = fnDl645Secret_Verify(0x04 , RxFrm->UDat.Dat[0] , &RxFrm->UDat.Dat[1]);
     
640.                 if(err != SUCCESS) return(DL645B_ERRINFO_PSW);
     
641.         }
     
642.         switch(DITemp)
     
643.         {
     
644.         case 0x00f81000:                                                                                //电流电压功率初校,HFCONST等参数设置
     
645.                 if(RxFrm->Len != (12+48)) return(DL645B_ERRINFO_DATA);
     
646.                
     
647.                 memcpy(&tempconst , &(RxFrm->UDat.Dat[8]) , 2);
     
648.                 memcpy(&temphfconst , &(RxFrm->UDat.Dat[10]) , 2);
     
649.                 memcpy(&tempub , &(RxFrm->UDat.Dat[12]) , 2);
     
650.                 memcpy(&tempus , &(RxFrm->UDat.Dat[14]) , 4);
     
651.                 memcpy(&tempib , &(RxFrm->UDat.Dat[18]) , 2);
     
652.                 memcpy(&tempis , &(RxFrm->UDat.Dat[20]) , 4);
     
653.                
     
654.                
     
655.                 Dl645FirmPara.ConstE=tempconst*10L;
     
656.                 Dl645RN7302DataComm.ucTemp8 = 0xe5; // 写使能位
     
657.                 fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
     
658.                 Dl645FirmPara.HFConst1 = temphfconst;
     
659.                 fnRN7302_Write(HFCONST1,(u8 *)&Dl645FirmPara.HFConst1,2);
     
660.                 fnDl645File_Write(Dl645FileId_FirmPara,26,(u8 *)&Dl645FirmPara.HFConst1,2);
     
661.                
     
662.                 for(i=0;i<3;i++)  //
     
663.                 {
     
664.                         memcpy(&temppw[0] , &(RxFrm->UDat.Dat[32+4*i]) , 4);
     
665.                         temppw[1] = tempus/tempub;
     
666.                         temppw[1] = (temppw[1] *temppw[0])/10;
     
667.                         fnRN7302_Read( 0x0007+ i , (u8 *)&temppw[0] , 4 ) ;
     
668.                         ADErr=((float)temppw[0]-(float)temppw[1])/temppw[1];
     
669.                         ADErr=(-ADErr/(1+ADErr));
     
670.                         if(ADErr>0) Dl645FirmPara.VGain[i]=(u16)(ADErr*32768);
     
671.                         else Dl645FirmPara.VGain[i] = (u16)(65535 + ADErr*32768);
     
672.                         fnRN7302_Write(GSUA+i,(u8 *)&Dl645FirmPara.VGain[i],2);
     
673.                         fnRN7302_Read( GSUA+i , Dl645RN7302DataComm.ucTempBuf , 2 ) ;
     
674.                 }
     
675.                 fnDl645File_Write(Dl645FileId_FirmPara,42,(u8 *)&Dl645FirmPara.VGain[0],6);
     
676.                
     
677.                 for(i=0;i<3;i++)   //电流增益校正
     
678.                 {
     
679.                         memcpy(&temppw[0] , &(RxFrm->UDat.Dat[44+4*i]) , 4);
     
680.                         temppw[1] = tempis/tempib;
     
681.                         temppw[1] = (temppw[1] *temppw[0])/10;
     
682.                         fnRN7302_Read( 0x000B+ i , (u8 *)&temppw[0] , 4 ) ;
     
683.                         ADErr=((float)temppw[0]-(float)temppw[1])/temppw[1];
     
684.                         ADErr=((-ADErr)/(1+ADErr));
     
685.                         if(ADErr>0) Dl645FirmPara.IGain[i]=(u16)(ADErr*32768);
     
686.                         else Dl645FirmPara.IGain[i] = (u16)(65535 + ADErr*32768);
     
687.                         fnRN7302_Write(GSIA+i,(u8 *)&Dl645FirmPara.IGain[i],2);
     
688.                 }
     
689.                 fnDl645File_Write(Dl645FileId_FirmPara,48,(u8 *)&Dl645FirmPara.IGain[0],8);
     
690.                
     
691.                
     
692.                 tempconst = fnHexToBcd_u16(tempconst) ;
     
693.                 ConstE.Dat0 = (((u8)(tempconst & 0x000f))<<4)&0xf0;
     
694.                 ConstE.Dat1 = (tempconst & 0x0ff0)>>4;
     
695.                 ConstE.Dat2 = (u8)((tempconst & 0xf000)>>12);
     
696.                
     
697.                
     
698.                 fnDl645File_Write(Dl645FileId_HighPara , Dl645FileItemInfoOffAddr_HighPara_PConstE , (u8 *)&ConstE , 3);
     
699.                 fnDl645File_Write(Dl645FileId_HighPara , Dl645FileItemInfoOffAddr_HighPara_QConstE , (u8 *)&ConstE , 3);
     
700.                
     
701.                 i=Dl645FirmPara.FractionI;
     
702.                 B=1;
     
703.                 while(i--)
     
704.                 {
     
705.                         B*=10;
     
706.                 }
     
707.                 B = B/1000;
     
708.                 Dl645FirmPara.IRmsConst=((float)tempis/((float)tempib*B));
     
709.                 fnDl645File_Write(Dl645FileId_FirmPara,10,(u8 *)&Dl645FirmPara.IRmsConst,4);
     
710.                
     
711.                 i=Dl645FirmPara.FractionU;
     
712.                 B=1;
     
713.                 while(i--)
     
714.                 {
     
715.                         B*=10;
     
716.                 }
     
717.                 B = B/100;
     
718.                 Dl645FirmPara.VRmsConst=((float)tempus/(tempub*B));
     
719.                 fnDl645File_Write(Dl645FileId_FirmPara,30,(u8 *)&Dl645FirmPara.VRmsConst,4);
     
720.                
     
721.                 Dl645FirmPara.NOLOAD = (u16)((tempis*0.0003)/16);
     
722.                 Dl645FirmPara.ZEROSTAR=(u16)((tempis*0.005)/4096);
     
723.                 fnRN7302_Write(IStart_PS,(u8 *)&Dl645FirmPara.NOLOAD,2);
     
724.                 fnRN7302_Write(ZXOT,(u8 *)&Dl645FirmPara.ZEROSTAR,2);
     
725.                 fnDl645File_Write(Dl645FileId_FirmPara,18,(u8 *)&Dl645FirmPara.NOLOAD,4);
     
726.                
     
727.                 // 功率系数计算
     
728.                 Dl645FirmPara.PRmsConst=(u32)((float)tempus*(float)tempis/((float)tempub*(float)tempib*838.8608));
     
729.                 fnDl645File_Write(Dl645FileId_FirmPara,36,(u8 *)&Dl645FirmPara.PRmsConst,4);
     
730.                
     
731.                 memcpy(&tempub , &(RxFrm->UDat.Dat[24]) , 2);
     
732.                 memcpy(&tempib , &(RxFrm->UDat.Dat[26]) , 2);
     
733.                
     
734.                 Dl645FirmPara.PRth[0] = tempub;
     
735.                 Dl645FirmPara.PRth[1] = tempib;
     
736.                
     
737.                 fnRN7302_Write(PRTH1L,(u8 *)&Dl645FirmPara.PRth[0],2);
     
738.                 fnRN7302_Write(PRTH1H,(u8 *)&Dl645FirmPara.PRth[1],2);
     
739.                
     
740.                 memcpy(&tempub , &(RxFrm->UDat.Dat[28]) , 2);
     
741.                 memcpy(&tempib , &(RxFrm->UDat.Dat[30]) , 2);
     
742.                
     
743.                 Dl645FirmPara.PRth[2] = tempub;
     
744.                 Dl645FirmPara.PRth[3] = tempib;
     
745.                
     
746.                 fnRN7302_Write(PRTH2L,(u8 *)&Dl645FirmPara.PRth[2],2);
     
747.                 fnRN7302_Write(PRTH2H,(u8 *)&Dl645FirmPara.PRth[3],2);
     
748.                 fnDl645File_Write(Dl645FileId_FirmPara,70,(u8 *)&Dl645FirmPara.PRth[0],8);
     
749.                
     
750.                 Dl645RN7302DataComm.ucTemp8 = 0xDC; // 写保护
     
751.                 fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);        
     
752.                 Dl645FirmPara.ChkSum1 = 0;
     
753.                 SystemDelay(10);
     
754.                 fnRN7302_Read( CheckSum1 , (u8 *)&Dl645FirmPara.ChkSum1 , 3 ) ;
     
755.                 fnDl645File_Write(Dl645FileId_FirmPara,22,(u8 *)&Dl645FirmPara.ChkSum1,3);
     
756.                 break;
     
757.         case 0x00f81100:                        //功率相位校准
     
758.                 if((RxFrm->Len != (12+18))&&(RxFrm->Len != (12+20))&&(RxFrm->Len != (12+5))) return(DL645B_ERRINFO_DATA);
     
759.                 if(RxFrm->Len == (12+5))
     
760.                 {
     
761.                     memcpy(&tempis , &(RxFrm->UDat.Dat[9]) , 4);
     
762.                         Dl645RN7302DataComm.ucTemp8 = 0xe5; // 写使能位
     
763.                         fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
     
764.                         if(tempis > 0x7fffffff) ADErr=-(float)(0xffffffff - tempis)/100000;
     
765.                     else ADErr=(float)tempis/100000;
     
766.                         ADErr = (asin(-ADErr/1.732))*57.29578/0.017578;                                // 弧度转成角度
     
767.                         if(Dl645FirmPara.PRth[0]==0 && Dl645FirmPara.PRth[1]==0 && Dl645FirmPara.PRth[2]==0 && Dl645FirmPara.PRth[3]==0)
     
768.                         {
     
769.                                 if(ADErr == 0) Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]] = 0x808080;
     
770.                                 else if(ADErr>0)  Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]] = 0x808080 - (u8)ADErr;
     
771.                                 else {ADErr = -ADErr;Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]] = 0x808080 + (u8)ADErr;}
     
772.                         }
     
773.                         else
     
774.                         {
     
775.                                 if(ADErr == 0) Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]] = (Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]]&0x00ff00ff)|0x8000;
     
776.                                 else if(ADErr>0)  Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]] = Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]] - (((u32)((u8)ADErr)<<8)&0x0000ff00);
     
777.                                 else {ADErr = -ADErr;Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]] = Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]] + (((u32)((u8)ADErr)<<8)&0x0000ff00);}
     
778.                         }
     
779.                         fnRN7302_Write(PHSIA+RxFrm->UDat.Dat[8],(u8 *)&Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]],3);
     
780.                 }
     
781.                 else
     
782.                 {
     
783.                         memcpy(&tempis , &(RxFrm->UDat.Dat[8]) , 4);
     
784.                         memcpy(&tempus , &(RxFrm->UDat.Dat[12]) , 4);
     
785.                         
     
786.                         Dl645FirmPara.PRmsConst=((float)tempus*100/(tempis/10));
     
787.                         
     
788.                         fnDl645File_Write(Dl645FileId_FirmPara,36,(u8 *)&Dl645FirmPara.PRmsConst,4);
     
789.                         
     
790.                         Dl645RN7302DataComm.ucTemp8 = 0xe5; // 写使能位
     
791.                         fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
     
792.                         if((RxFrm->Len == (12+18)))
     
793.                         {
     
794.                                 tempangle[0] =0;
     
795.                                 
     
796.                                 for(i=0;i<2;i++)
     
797.                                 {
     
798.                                         fnRN7302_Read( YUB+i , Dl645RN7302DataComm.ucTempBuf , 3 ) ;
     
799.                                         temppw[0] =Dl645RN7302DataComm.lTemp32 & 0x00ffffff;
     
800.                                         tempangle[i+1] = (u16)(((float)temppw[0]/16777216)*36000);
     
801.                                 }
     
802.                                 
     
803.                                 for(i=0;i<3;i++)
     
804.                                 {
     
805.                                         memcpy(&tempangle[i+3] , &(RxFrm->UDat.Dat[20+2*i]) , 2);
     
806.                                         fnRN7302_Read( YIA+i , Dl645RN7302DataComm.ucTempBuf , 3 ) ;
     
807.                                         temppw[0] =Dl645RN7302DataComm.lTemp32 & 0x00ffffff;
     
808.                                         ADErr = ((((float)temppw[0]/16777216)*36000-(float)(tempangle[i+3]+tempangle[i]))/1.7578);
     
809.                                         if(Dl645FirmPara.PRth[0]==0 && Dl645FirmPara.PRth[1]==0 && Dl645FirmPara.PRth[2]==0 && Dl645FirmPara.PRth[3]==0)
     
810.                                         {
     
811.                                                 if(ADErr>0)  Dl645FirmPara.PHSI[i] = 0x808080 - (u8)ADErr;
     
812.                                                 else {ADErr = -ADErr;Dl645FirmPara.PHSI[i] = 0x808080 + (u8)ADErr;}
     
813.                                         }
     
814.                                         else
     
815.                                         {
     
816.                                                 if(ADErr>0)  Dl645FirmPara.PHSI[i] = Dl645FirmPara.PHSI[i] - (((u32)((u8)ADErr)<<8)&0x0000ff00);
     
817.                                                 else {ADErr = -ADErr;Dl645FirmPara.PHSI[i] = Dl645FirmPara.PHSI[i] + (((u32)((u8)ADErr)<<8)&0x0000ff00);}
     
818.                                         }
     
819.                                         fnRN7302_Write(PHSIA+i,(u8 *)&Dl645FirmPara.PHSI[i],3);
     
820.                                 }
     
821.                         }
     
822.                         else
     
823.                         {
     
824.                                 for(i=0;i<3;i++)
     
825.                                 {
     
826.                                         fnRN7302_Read( 0x0014+i , Dl645RN7302DataComm.ucTempBuf , 4 ) ;
     
827.                                         temppw[0] =Dl645RN7302DataComm.lTemp32;
     
828.                                        
     
829.                                         memcpy(&temppw[1] , &(RxFrm->UDat.Dat[16 + 4*i]) , 4);
     
830.                                         temppw[1] = (u32)(((float)tempus/(float)tempis)*(float)temppw[1]);
     
831.                                         ADErr=((float)temppw[0]-(float)temppw[1])/(float)temppw[1];
     
832.                                         ADErr = (asin(-ADErr/1.732))*57.29578/0.017578;                                // 弧度转成角度
     
833.                                         if(Dl645FirmPara.PRth[0]==0 && Dl645FirmPara.PRth[1]==0 && Dl645FirmPara.PRth[2]==0 && Dl645FirmPara.PRth[3]==0)
     
834.                                         {
     
835.                                                 if(ADErr>0)  Dl645FirmPara.PHSI[i] = 0x808080 - (u8)ADErr;
     
836.                                                 else {ADErr = -ADErr;Dl645FirmPara.PHSI[i] = 0x808080 + (u8)ADErr;}
     
837.                                         }
     
838.                                         else
     
839.                                         {
     
840.                                                 if(ADErr>0)  Dl645FirmPara.PHSI[i] = Dl645FirmPara.PHSI[i] - (((u32)((u8)ADErr)<<8)&0x0000ff00);
     
841.                                                 else {ADErr = -ADErr;Dl645FirmPara.PHSI[i] = Dl645FirmPara.PHSI[i] + (((u32)((u8)ADErr)<<8)&0x0000ff00);}
     
842.                                         }
     
843.                                         fnRN7302_Write(PHSIA+i,(u8 *)&Dl645FirmPara.PHSI[i],3);
     
844.                                 }
     
845.                         }
     
846.                 }
     
847.                 fnDl645File_Write(Dl645FileId_FirmPara,56,(u8 *)&Dl645FirmPara.PHSU[0],14);
     
848.                
     
849.                 Dl645RN7302DataComm.ucTemp8 = 0xDC; // 写保护
     
850.                 fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
     
851.                 Dl645FirmPara.ChkSum1 = 0;
     
852.                 SystemDelay(10);
     
853.                 fnRN7302_Read( CheckSum1 , (u8 *)&Dl645FirmPara.ChkSum1 , 3 ) ;
     
854.                 fnDl645File_Write(Dl645FileId_FirmPara,22,(u8 *)&Dl645FirmPara.ChkSum1,3);
     
855.                 break;
     
856.         case 0x00f81102:                        //功率相位校准分段1
     
857.                 if((RxFrm->Len != (12+10))&&(RxFrm->Len != (12+20))&&(RxFrm->Len != (12+5))) return(DL645B_ERRINFO_DATA);
     
858.                 if(Dl645FirmPara.PRth[0]==0 && Dl645FirmPara.PRth[1]==0 && Dl645FirmPara.PRth[2]==0 && Dl645FirmPara.PRth[3]==0) return(DL645B_ERRINFO_DATA);
     
859.                 Dl645RN7302DataComm.ucTemp8 = 0xe5; // 写使能位
     
860.                 fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
     
861.                 if(RxFrm->Len == (12+10))
     
862.                 {
     
863.                         tempangle[0] =0;
     
864.                         for(i=0;i<2;i++)
     
865.                         {
     
866.                                 fnRN7302_Read( YUB+i , Dl645RN7302DataComm.ucTempBuf , 3 ) ;
     
867.                                 temppw[0] =Dl645RN7302DataComm.lTemp32 & 0x00ffffff;
     
868.                                 tempangle[i+1] = (u16)(((float)temppw[0]/16777216)*36000);
     
869.                         }
     
870.                         
     
871.                         for(i=0;i<3;i++)
     
872.                         {
     
873.                                 memcpy(&tempangle[i+3] , &(RxFrm->UDat.Dat[12+2*i]) , 2);
     
874.                                 fnRN7302_Read( YIA+i , Dl645RN7302DataComm.ucTempBuf , 3 ) ;
     
875.                                 //fnRN7302_Read( YIA+i , (u8 *)&temppw[0] , 3 ) ;
     
876.                                 temppw[0] =Dl645RN7302DataComm.lTemp32 & 0x00ffffff;
     
877.                                 ADErr = ((((float)temppw[0]/16777216)*36000-(tempangle[i+3]+tempangle[i]))/1.7578);
     
878.                                 if(ADErr>0)  Dl645FirmPara.PHSI[i] = ((Dl645FirmPara.PHSI[i]&0xffff00)|0x000080) - (u8)ADErr;
     
879.                                 else {ADErr = -ADErr;Dl645FirmPara.PHSI[i] = ((Dl645FirmPara.PHSI[i]&0xffff00)|0x000080) + (u8)ADErr;}
     
880.                                 fnRN7302_Write(PHSIA+i,(u8 *)&Dl645FirmPara.PHSI[i],3);
     
881.                         }
     
882.                 }
     
883.                 else if(RxFrm->Len == (12+20))
     
884.                 {
     
885.                         memcpy(&tempis , &(RxFrm->UDat.Dat[8]) , 4);
     
886.                         memcpy(&tempus , &(RxFrm->UDat.Dat[12]) , 4);
     
887.                         
     
888.                         for(i=0;i<3;i++)
     
889.                         {
     
890.                                 fnRN7302_Read( 0x0014+i , Dl645RN7302DataComm.ucTempBuf , 4 ) ;
     
891.                                 temppw[0] =Dl645RN7302DataComm.lTemp32;
     
892.                                 
     
893.                                 memcpy(&temppw[1] , &(RxFrm->UDat.Dat[16 + 4*i]) , 4);
     
894.                                 temppw[1] = (u32)(((float)tempus/(float)tempis)*(float)temppw[1]);
     
895.                                 ADErr=((float)temppw[0]-(float)temppw[1])/(float)temppw[1];
     
896.                                 ADErr = (asin(-ADErr/1.732))*57.29578/0.017578;                                // 弧度转成角度
     
897.                                 if(ADErr>0)  Dl645FirmPara.PHSI[i] = ((Dl645FirmPara.PHSI[i]&0xffff00)|0x000080) - (u8)ADErr;
     
898.                                 else {ADErr = -ADErr;Dl645FirmPara.PHSI[i] = ((Dl645FirmPara.PHSI[i]&0xffff00)|0x000080) + (u8)ADErr;}
     
899.                                 fnRN7302_Write(PHSIA+i,(u8 *)&Dl645FirmPara.PHSI[i],3);
     
900.                         }
     
901.                 }
     
902.                 else
     
903.                 {
     
904.                     memcpy(&tempis , &(RxFrm->UDat.Dat[9]) , 4);
     
905.                         Dl645RN7302DataComm.ucTemp8 = 0xe5; // 写使能位
     
906.                         fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
     
907.                         if(tempis > 0x7fffffff) ADErr=-(float)(0xffffffff - tempis)/100000;
     
908.                     else ADErr=(float)tempis/100000;
     
909.                         ADErr = (asin(-ADErr/1.732))*57.29578/0.017578;                                // 弧度转成角度
     
910.                         if(ADErr>0)  Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]] = ((Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]]&0xffff00)|0x000080) - (u8)ADErr;
     
911.                         else {ADErr = -ADErr;Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]] = ((Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]]&0xffff00)|0x000080) + (u8)ADErr;}
     
912.                         fnRN7302_Write(PHSIA+RxFrm->UDat.Dat[8],(u8 *)&Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]],3);
     
913.                 }
     
914.                 fnDl645File_Write(Dl645FileId_FirmPara,56,(u8 *)&Dl645FirmPara.PHSU[0],14);
     
915.                 Dl645RN7302DataComm.ucTemp8 = 0xDC; // 写保护
     
916.                 fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
     
917.                 Dl645FirmPara.ChkSum1 = 0;
     
918.                 SystemDelay(10);
     
919.                 fnRN7302_Read( CheckSum1 , (u8 *)&Dl645FirmPara.ChkSum1 , 3 ) ;
     
920.                 fnDl645File_Write(Dl645FileId_FirmPara,22,(u8 *)&Dl645FirmPara.ChkSum1,3);
     
921.                 break;
     
922.         case 0x00f81103:
     
923.                 if((RxFrm->Len != (12+10))&&(RxFrm->Len != (12+20))&&(RxFrm->Len != (12+5))) return(DL645B_ERRINFO_DATA);
     
924.                 if(Dl645FirmPara.PRth[0]==0 && Dl645FirmPara.PRth[1]==0 && Dl645FirmPara.PRth[2]==0 && Dl645FirmPara.PRth[3]==0) return(DL645B_ERRINFO_DATA);
     
925.                 Dl645RN7302DataComm.ucTemp8 = 0xe5; // 写使能位
     
926.                 fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
     
927.                 if(RxFrm->Len == (12+10))
     
928.                 {        
     
929.                         tempangle[0] =0;
     
930.                         for(i=0;i<2;i++)
     
931.                         {
     
932.                                 fnRN7302_Read( YUB+i , Dl645RN7302DataComm.ucTempBuf , 3 ) ;
     
933.                                 temppw[0] =Dl645RN7302DataComm.lTemp32 & 0x00ffffff;
     
934.                                 tempangle[i+1] = (u16)(((float)temppw[0]/16777216)*36000);
     
935.                         }
     
936.                         for(i=0;i<3;i++)
     
937.                         {
     
938.                                 memcpy(&tempangle[i+3] , &(RxFrm->UDat.Dat[12+2*i]) , 2);
     
939.                                 fnRN7302_Read( YIA+i , Dl645RN7302DataComm.ucTempBuf , 3 ) ;
     
940.                                 temppw[0] =Dl645RN7302DataComm.lTemp32 & 0x00ffffff;
     
941.                                 ADErr = ((((float)temppw[0]/16777216)*36000-(tempangle[i+3]+tempangle[i]))/1.7578);
     
942.                                 if(ADErr>0)  Dl645FirmPara.PHSI[i] = ((Dl645FirmPara.PHSI[i]&0x00ffff)|0x800000) - (((u32)((u8)ADErr)*65536)&0x00ff0000);
     
943.                                 else {ADErr = -ADErr;Dl645FirmPara.PHSI[i] = ((Dl645FirmPara.PHSI[i]&0x00ffff)|0x800000) + (((u32)((u8)ADErr)*65536)&0x00ff0000);}
     
944.                                 fnRN7302_Write(PHSIA+i,(u8 *)&Dl645FirmPara.PHSI[i],3);
     
945.                         }
     
946.                 }
     
947.                 else if((RxFrm->Len == (12+20)))
     
948.                 {
     
949.                         memcpy(&tempis , &(RxFrm->UDat.Dat[8]) , 4);
     
950.                         memcpy(&tempus , &(RxFrm->UDat.Dat[12]) , 4);
     
951.                         
     
952.                         for(i=0;i<3;i++)
     
953.                         {
     
954.                                 fnRN7302_Read( 0x0014+i , Dl645RN7302DataComm.ucTempBuf , 4 ) ;
     
955.                                 temppw[0] =Dl645RN7302DataComm.lTemp32;
     
956.                                 
     
957.                                 memcpy(&temppw[1] , &(RxFrm->UDat.Dat[16 + 4*i]) , 4);
     
958.                                 temppw[1] = (u32)(((float)tempus/(float)tempis)*(float)temppw[1]);
     
959.                                 ADErr=((float)temppw[0]-(float)temppw[1])/(float)temppw[1];
     
960.                                 ADErr = (asin(-ADErr/1.732))*57.29578/0.017578;                                // 弧度转成角度
     
961.                                 if(ADErr>0)  Dl645FirmPara.PHSI[i] = ((Dl645FirmPara.PHSI[i]&0x00ffff)|0x800000) - (((u32)((u8)ADErr)*65536)&0x00ff0000);
     
962.                                 else {ADErr = -ADErr;Dl645FirmPara.PHSI[i] = ((Dl645FirmPara.PHSI[i]&0x00ffff)|0x800000) + (((u32)((u8)ADErr)*65536)&0x00ff0000);}
     
963.                                 fnRN7302_Write(PHSIA+i,(u8 *)&Dl645FirmPara.PHSI[i],3);
     
964.                         }
     
965.                 }
     
966.                 else
     
967.                 {
     
968.                         memcpy(&tempis , &(RxFrm->UDat.Dat[9]) , 4);
     
969.                         Dl645RN7302DataComm.ucTemp8 = 0xe5; // 写使能位
     
970.                         fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
     
971.                         if(tempis > 0x7fffffff) ADErr=-(float)(0xffffffff - tempis)/100000;
     
972.                     else ADErr=(float)tempis/100000;
     
973.                         ADErr = (asin(-ADErr/1.732))*57.29578/0.017578;                                // 弧度转成角度
     
974.                         if(ADErr>0)  Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]] = ((Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]]&0x00ffff)|0x800000) - (((u32)((u8)ADErr)*65536)&0x00ff0000);
     
975.                         else {ADErr = -ADErr;Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]] = ((Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]]&0x00ffff)|0x800000) + (((u32)((u8)ADErr)*65536)&0x00ff0000);}
     
976.                         fnRN7302_Write(PHSIA+RxFrm->UDat.Dat[8],(u8 *)&Dl645FirmPara.PHSI[RxFrm->UDat.Dat[8]],3);
     
977.                 }
     
978.                 fnDl645File_Write(Dl645FileId_FirmPara,56,(u8 *)&Dl645FirmPara.PHSU[0],14);
     
979.                
     
980.                 Dl645RN7302DataComm.ucTemp8 = 0xDC; // 写保护
     
981.                 fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
     
982.                 Dl645FirmPara.ChkSum1 = 0;
     
983.                 SystemDelay(10);
     
984.                 fnRN7302_Read( CheckSum1 , (u8 *)&Dl645FirmPara.ChkSum1 , 3 ) ;
     
985.                 fnDl645File_Write(Dl645FileId_FirmPara,22,(u8 *)&Dl645FirmPara.ChkSum1,3);
     
986.                 break;
     
987.         case 0x00f81501:                // 误差校正功率增益
     
988.                 if(RxFrm->Len != (12+5)) return(DL645B_ERRINFO_DATA);
     
989.                 if(RxFrm->UDat.Dat[8]>0x03) return(DL645B_ERRINFO_DATA);
     
990.                 memcpy(&tempis , &(RxFrm->UDat.Dat[9]) , 4);
     
991.                 Dl645RN7302DataComm.ucTemp8 = 0xe5; // 写使能位
     
992.                 fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
     
993.             if(tempis > 0x7fffffff) ADErr=-(float)(0xffffffff - tempis)/100000;
     
994.             else ADErr=(float)tempis/100000;
     
995.                 ADErr=((-ADErr)/(1+ADErr));
     
996.                 if(ADErr>=0) Dl645FirmPara.PGain[RxFrm->UDat.Dat[8]]=(u16)(ADErr*32768);
     
997.                 else Dl645FirmPara.PGain[RxFrm->UDat.Dat[8]] = (u16)(65535 + ADErr*32768);
     
998.                 fnRN7302_Write(GPA+RxFrm->UDat.Dat[8],(u8 *)&Dl645FirmPara.PGain[RxFrm->UDat.Dat[8]],2);
     
999.                 fnRN7302_Write(GQA+RxFrm->UDat.Dat[8],(u8 *)&Dl645FirmPara.PGain[RxFrm->UDat.Dat[8]],2);
     
1000.                 fnRN7302_Write(GSA+RxFrm->UDat.Dat[8],(u8 *)&Dl645FirmPara.PGain[RxFrm->UDat.Dat[8]],2);
      
1001.                 Dl645RN7302DataComm.ucTemp8 = 0xDC; // 写保护
      
1002.                 fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
      
1003.                 fnDl645File_Write(Dl645FileId_FirmPara,98,(u8 *)&Dl645FirmPara.PGain[0],6);
      
1004.                 Dl645FirmPara.ChkSum1 = 0;
      
1005.                 SystemDelay(10);
      
1006.                 fnRN7302_Read( CheckSum1 , (u8 *)&Dl645FirmPara.ChkSum1 , 3 ) ;
      
1007.                 fnDl645File_Write(Dl645FileId_FirmPara,22,(u8 *)&Dl645FirmPara.ChkSum1,3);
      
1008.             break;
      
1009.         case 0x00f81600:
      
1010.                 if((RxFrm->Len != (12 + 1)) && (RxFrm->UDat.Dat[8] != 0x5A)) return(DL645B_ERRINFO_DATA);
      
1011.                 Dl645RN7302DataComm.ucTemp8 = 0xe5; // 写使能位
      
1012.                 fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
      
1013.                 for(i=0;i<3;i++)
      
1014.                 {
      
1015.                         Dl645FirmPara.VGain[i]=0;
      
1016.                         fnRN7302_Write(GSUA+i,(u8 *)&Dl645FirmPara.VGain[i],2);
      
1017.                         Dl645FirmPara.IGain[i]=0;               
      
1018.                         fnRN7302_Write(GSIA+i,(u8 *)&Dl645FirmPara.IGain[i],2);                                                               
      
1019.                 }
      
1020.                 for(i=0;i<2;i++)
      
1021.                 {
      
1022.                         Dl645FirmPara.PHSU[i]=0x80;
      
1023.                         fnRN7302_Write(PHSUB+i,(u8 *)&Dl645FirmPara.PHSU[i],1);
      
1024.                 }
      
1025.                 for(i=0;i<3;i++)
      
1026.                 {
      
1027.                         Dl645FirmPara.PHSI[i]=0x808080;
      
1028.                         fnRN7302_Write(PHSUB+i,(u8 *)&Dl645FirmPara.PHSI[i],3);
      
1029.                 }
      
1030.                 for(i=0;i<3;i++)
      
1031.                 {
      
1032.                         Dl645FirmPara.P_PHS[i]=0;
      
1033.                         fnRN7302_Write(PA_PHS+i,(u8 *)&Dl645FirmPara.P_PHS[i],2);
      
1034.                 }
      
1035.                 for(i=0;i<3;i++)
      
1036.                 {
      
1037.                         Dl645FirmPara.P_PHS[i]=0;
      
1038.                         fnRN7302_Write(PA_PHS+i,(u8 *)&Dl645FirmPara.P_PHS[i],2);
      
1039.                 }
      
1040.                 for(i=0;i<3;i++)
      
1041.                 {
      
1042.                         Dl645FirmPara.PGain[i]=0;
      
1043.                         fnRN7302_Write(GPA+i,(u8 *)&Dl645FirmPara.PGain[i],2);
      
1044.                         fnRN7302_Write(GQA+i,(u8 *)&Dl645FirmPara.PGain[i],2);
      
1045.                         fnRN7302_Write(GSA+i,(u8 *)&Dl645FirmPara.PGain[i],2);
      
1046.                 }
      
1047.                 Dl645FirmPara.PRth[0] = 0x0;
      
1048.                 Dl645FirmPara.PRth[1] = 0x0;
      
1049.                 Dl645FirmPara.PRth[2] = 0x0;
      
1050.                 Dl645FirmPara.PRth[3] = 0x0;
      
1051.                 fnRN7302_Write(PRTH1L,(u8 *)&Dl645FirmPara.PRth[0],2);
      
1052.                 fnRN7302_Write(PRTH1H,(u8 *)&Dl645FirmPara.PRth[1],2);
      
1053.                 fnRN7302_Write(PRTH2L,(u8 *)&Dl645FirmPara.PRth[2],2);
      
1054.                 fnRN7302_Write(PRTH2H,(u8 *)&Dl645FirmPara.PRth[3],2);
      
1055.                
      
1056.                 Dl645RN7302DataComm.ucTemp8 = 0xDC; // 写保护
      
1057.                 fnRN7302_Write(0x0180,Dl645RN7302DataComm.ucTempBuf,1);
      
1058.                 fnDl645File_Write(Dl645FileId_FirmPara,42,(u8 *)&Dl645FirmPara.VGain[0],6);
      
1059.                 fnDl645File_Write(Dl645FileId_FirmPara,48,(u8 *)&Dl645FirmPara.IGain[0],8);
      
1060.                 fnDl645File_Write(Dl645FileId_FirmPara,56,(u8 *)&Dl645FirmPara.PHSU[0],14);
      
1061.                 fnDl645File_Write(Dl645FileId_FirmPara,70,(u8 *)&Dl645FirmPara.PRth[0],8);
      
1062.                 fnDl645File_Write(Dl645FileId_FirmPara,92,(u8 *)&Dl645FirmPara.P_PHS[0],12);
      
1063.                 fnDl645File_Write(Dl645FileId_FirmPara,98,(u8 *)&Dl645FirmPara.PGain[0],6);
      
1064.                 Dl645FirmPara.ChkSum1 = 0;
      
1065.                 SystemDelay(10);
      
1066.                 fnRN7302_Read( CheckSum1 , (u8 *)&Dl645FirmPara.ChkSum1 , 3 ) ;
      
1067.                 fnDl645File_Write(Dl645FileId_FirmPara,22,(u8 *)&Dl645FirmPara.ChkSum1,3);
      
1068.                 break;
      
1069.     }               
      
1070. }
      
1071. 
      

复制代码

只有一个c文件,不完整,求大家补全：
RN7302_Demo_V1.1.rar (6.25 KB, 下载次数: 375)

2018-5-11 16:39 上传

点击文件名下载附件
驱动

RN7302三相表_page1_V1.0.rar (24.19 KB, 下载次数: 388)

2018-5-11 16:39 上传

点击文件名下载附件
原理图

(原理图)

---

作者: wangci152006    时间: 2018-6-26 15:08
只有.c文件,只能看个大概的思路 不建议下载

---

作者: lyema    时间: 2018-8-11 09:53
资料不多，怎么还要分两次下载

---

作者: smofx    时间: 2018-9-22 17:12
具有一定的参考价值

---

作者: zwdwell     时间: 2019-1-14 14:29
B相电流怎么测

---

作者: h8924    时间: 2019-1-22 12:20

具有一定的参考价值

---

作者: hfahuang    时间: 2019-1-23 01:02
具有一定的参考价值

---

作者: 右走    时间: 2019-1-30 20:54
很不错的资料

---

作者: 心有邻    时间: 2019-3-21 14:57
感谢楼主

---

作者: dsldsldsldsl    时间: 2019-4-26 12:23
可以参考一下

---

作者: lbq666    时间: 2019-8-19 13:14
下载了，谢谢分享

---

作者: yjwpm    时间: 2019-12-24 12:54

下载了，谢谢分享

---

作者: yjwpm    时间: 2019-12-24 12:54
下载了，谢谢分享

---

作者: TEACHER33    时间: 2020-1-10 09:11
可以参考一下

---

作者: justToWing    时间: 2020-2-2 12:02
谢谢分享

---

作者: stn13135    时间: 2020-3-13 09:05
具有一定的参考价值

---

作者: ddlxr    时间: 2020-3-23 11:13
RN7302怎么这么复杂

---

作者: 51550461    时间: 2020-6-17 21:07
可以参考一下

---

作者: melin    时间: 2021-4-6 14:48
正好用来学习一下啊 为什么发不出去？

---

作者: 蓝色天空1988    时间: 2021-8-16 09:41
具有一定的参考价值

---

作者: laisongside    时间: 2022-2-9 21:51
原理图只有PAGE1，少一张？

---

作者: hange_v    时间: 2022-3-1 21:43
比ATT7022E好用吗？

---

作者: qinshuai    时间: 2022-4-20 17:53

zwdwell         发表于 2019-1-14 14:29
B相电流怎么测

三相三线接法时没有B相电流，但是可以用A相C相合成一个B相电流。

---

作者: qinshuai    时间: 2022-4-20 17:55

hange_v 发表于 2022-3-1 21:43
比ATT7022E好用吗？

7302用的还挺好的，公司里用的还行

---

作者: 零空间    时间: 2022-5-23 09:25
你的图上为啥都没有RN7302，画的是啥啊

---

作者: harvardx    时间: 2023-5-1 22:55
Mark一下。  正在学习相关资料

---

作者: bstljq    时间: 2024-2-18 11:59

qinshuai 发表于 2022-4-20 17:55
7302用的还挺好的，公司里用的还行

大佬能解答一下锐能微计量芯片的一些问题吗？给个思路就选行，有红包

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1