adc.c 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622
  1. /************************************************************************
  2. Project: Welling Motor Control Paltform
  3. Filename: adc.c
  4. Partner Filename: adc.h
  5. Description: Get the adc conversion results
  6. Complier: IAR Embedded Workbench for ARM 7.80, IAR Systems.
  7. CPU TYPE : GD32F3x0
  8. *************************************************************************
  9. Copyright (c) 2018 Welling Motor Technology(Shanghai) Co. Ltd.
  10. All rights reserved.
  11. *************************************************************************
  12. *************************************************************************
  13. Revising History (ECL of this file):
  14. ************************************************************************/
  15. /************************************************************************
  16. Beginning of File, do not put anything above here except notes
  17. Compiler Directives:
  18. *************************************************************************/
  19. #ifndef _ADCDRV_C_
  20. #define _ADCDRV_C_
  21. #endif
  22. /************************************************************************
  23. Included File:
  24. *************************************************************************/
  25. #include "syspar.h"
  26. #include "user.h"
  27. #include "Temp.h"
  28. #include "api.h"
  29. #include "sys_ctrl.h"
  30. /************************************************************************
  31. Constant Table:
  32. *************************************************************************/
  33. /************************************************************************
  34. Exported Functions:
  35. *************************************************************************/
  36. /***************************************************************
  37. Function: adc_voCalibration;
  38. Description: Get phase A and B current zero point, other A/D sample value
  39. Call by: main() before InitADC;
  40. Input Variables: N/A
  41. Output/Return Variables: ADCTESTOUT
  42. Subroutine Call: N/A
  43. Reference: N/A
  44. ****************************************************************/
  45. void adc_voCalibration(ADC_COF *cof, ADC_DOWN_OUT *out1, ADC_UP_OUT *out2)
  46. {
  47. if (out1->blADCCalibFlg == FALSE || out2->blADCCalibFlg == FALSE)
  48. {
  49. if (!sysctrl_stPwmState.blChargeOvrFlg)
  50. {
  51. sysctrl_voCharge();
  52. }
  53. else
  54. {
  55. if(cp_stFlg.CurrentSampleModelSelect == COMBINATION)
  56. {
  57. ULONG samplingTick[2];
  58. samplingTick[0] = HW_INIT_HHHPWM_PERIOD;
  59. samplingTick[1] = 129;
  60. iPwm_SyncMultiSamplingCountUp(0, &samplingTick[0], 2);
  61. pwm_stGenOut.blSampleCalibFlag = TRUE;
  62. if (out1->uwADCCalibCt < (1 << ADC_CALIB_INDEX))
  63. {
  64. out1->ulIdcRegSum += iAdc_GetResultPointer(2)[HW_ADC_IDC_CH];
  65. out1->ulIaRegSum += iAdc_GetResultPointer(1)[HW_ADC_IA_CH];
  66. out1->ulIbRegSum += iAdc_GetResultPointer(1)[HW_ADC_IB_CH];
  67. out1->ulIcRegSum += iAdc_GetResultPointer(1)[HW_ADC_IC_CH];
  68. out1->uwADCCalibCt++;
  69. }
  70. else
  71. {
  72. sysctrl_voPwmInit(); // mos up charge and adc calib over; pwm off
  73. cof->uwIaOffset = (UWORD)(out1->ulIaRegSum >> (ADC_CALIB_INDEX));
  74. cof->uwIbOffset = (UWORD)(out1->ulIbRegSum >> (ADC_CALIB_INDEX));
  75. cof->uwIcOffset = (UWORD)(out1->ulIcRegSum >> (ADC_CALIB_INDEX));
  76. out1->ulIaRegSum = 0;
  77. out1->ulIbRegSum = 0;
  78. out1->ulIcRegSum = 0;
  79. pwm_stGenOut.blSampleCalibFlag = FALSE;
  80. cof->uwIdcOffset = (UWORD)(out1->ulIdcRegSum >> ADC_CALIB_INDEX);
  81. out1->ulIdcRegSum = 0;
  82. out1->uwADCCalibCt = 0;
  83. out1->blADCCalibFlg = TRUE;
  84. out2->uwADCCalibCt = 0;
  85. out2->blADCCalibFlg = TRUE;
  86. }
  87. }
  88. // else if(cp_stFlg.CurrentSampleModelSelect == SINGLERESISITANCE)
  89. // {
  90. // if (out1->uwADCCalibCt < (1 << ADC_CALIB_INDEX))
  91. // {
  92. // out1->ulIdcRegSum += adc_uwADDMAPhase1 + adc_uwADDMAPhase2;
  93. // out1->uwADCCalibCt++;
  94. // }
  95. // else if (out2->uwADCCalibCt < (1 << ADC_CALIB_INDEX))
  96. // {
  97. // out2->uwADCCalibCt++;
  98. // }
  99. // else
  100. // {
  101. // sysctrl_voPwmInit();
  102. // cof->uwIdcOffset = out1->ulIdcRegSum >> (ADC_CALIB_INDEX + 1);
  103. // out1->ulIdcRegSum = 0;
  104. // out1->uwADCCalibCt = 0;
  105. // out1->blADCCalibFlg = TRUE;
  106. // out2->uwADCCalibCt = 0;
  107. // out2->blADCCalibFlg = TRUE;
  108. // }
  109. // }
  110. // else if(cp_stFlg.CurrentSampleModelSelect == RDSON)
  111. // {
  112. // if (out1->uwADCCalibCt < (1 << ADC_CALIB_INDEX))
  113. // {
  114. // out1->ulIaRegSum += adc_uwRdsonUReg;
  115. // out1->ulIbRegSum += adc_uwRdsonVReg;
  116. // out1->ulIcRegSum += adc_uwRdsonWReg;
  117. // out1->uwADCCalibCt++;
  118. // }
  119. // else
  120. // {
  121. // sysctrl_voPwmInit();
  122. // // cof->uwIaOffset = 2048 ;
  123. // // cof->uwIbOffset = 2048;
  124. // // cof->uwIcOffset = 2048;
  125. // cof->uwIaOffset = out1->ulIaRegSum >> (ADC_CALIB_INDEX);
  126. // cof->uwIbOffset = out1->ulIbRegSum >> (ADC_CALIB_INDEX);
  127. // cof->uwIcOffset = out1->ulIcRegSum >> (ADC_CALIB_INDEX);
  128. //
  129. // out1->ulIaRegSum = 0;
  130. // out1->ulIbRegSum = 0;
  131. // out1->ulIcRegSum = 0;
  132. // out1->uwADCCalibCt = 0;
  133. // out1->blADCCalibFlg = TRUE;
  134. // out2->uwADCCalibCt = 0;
  135. // out2->blADCCalibFlg = TRUE;
  136. // }
  137. // }
  138. else
  139. {
  140. //do nothing
  141. }
  142. }
  143. }
  144. }
  145. /***************************************************************
  146. Function: adc_voSample;
  147. Description: Get three-phase current value after zero point and gain process
  148. Call by: functions in TBC;
  149. Input Variables: ADCIABFIXCOF
  150. Output/Return Variables: ADCTESTOUT
  151. Subroutine Call:
  152. Reference: N/A
  153. ****************************************************************/
  154. void adc_voSampleDown(const ADC_COF *cof, ADC_DOWN_OUT *out)
  155. {
  156. UWORD uwIpeakPu;
  157. if(cp_stFlg.CurrentSampleModelSelect == COMBINATION)
  158. {
  159. out->uwIaReg = iAdc_GetResultPointer(1)[HW_ADC_IA_CH];
  160. out->uwIbReg = iAdc_GetResultPointer(1)[HW_ADC_IB_CH];
  161. out->uwIcReg = iAdc_GetResultPointer(1)[HW_ADC_IC_CH];
  162. out->slSampIaPu = -(((SWORD)out->uwIaReg - (SWORD)cof->uwIaOffset) * (SLONG)cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
  163. out->slSampIbPu = -(((SWORD)out->uwIbReg - (SWORD)cof->uwIbOffset) * (SLONG)cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
  164. out->slSampIcPu = -(((SWORD)out->uwIcReg - (SWORD)cof->uwIcOffset) * (SLONG)cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
  165. out->swIaPu = (SWORD)((out->slSampIaPu * (SLONG)cof->uwCalibcoef) >> 10);
  166. out->swIbPu = (SWORD)((out->slSampIbPu * (SLONG)cof->uwCalibcoef) >> 10);
  167. out->swIcPu = (SWORD)((out->slSampIcPu * (SLONG)cof->uwCalibcoef) >> 10);
  168. }
  169. /*else if(cp_stFlg.CurrentSampleModelSelect == SINGLERESISITANCE)
  170. {
  171. SWORD tmp_swIphase1, tmp_swIphase2, tmp_swIphase3;
  172. // // Wait Injected ADC over
  173. // while(ADC_GetFlagStatus(ADC1,ADC_IT_JEOS) == RESET)
  174. // {}
  175. // ADC_ClearFlag(ADC1,ADC_IT_JEOS);
  176. // Register value
  177. out->uwFirstCurREG = adc_uwADDMAPhase1; // Q12
  178. out->uwSecondCurREG = adc_uwADDMAPhase2; // Q12
  179. tmp_swIphase1 = (SWORD)out->uwFirstCurREG - cof->uwIdcOffset;
  180. tmp_swIphase1 = ((SLONG)tmp_swIphase1 * cof->uwCurIdcReg2Pu) >> 10; // Q14=Q24-Q10
  181. tmp_swIphase2 = (SWORD)cof->uwIdcOffset - out->uwSecondCurREG;
  182. tmp_swIphase2 = ((SLONG)tmp_swIphase2 * cof->uwCurIdcReg2Pu) >> 10; // Q14=Q24-Q10
  183. tmp_swIphase3 = (SWORD)out->uwSecondCurREG - out->uwFirstCurREG;
  184. tmp_swIphase3 = ((SLONG)tmp_swIphase3 * cof->uwCurIdcReg2Pu) >> 10; // Q14=Q24-Q10
  185. out->uwADCSector = pwm_stGenOut.uwNewSectorNum;
  186. switch (pwm_stGenOut.uwNewSectorNum)
  187. {
  188. case 1:
  189. out->swIbPu = tmp_swIphase1; // v
  190. out->swIcPu = tmp_swIphase2; //-w
  191. out->swIaPu = tmp_swIphase3; // u
  192. break;
  193. case 2:
  194. out->swIaPu = tmp_swIphase1; // u
  195. out->swIbPu = tmp_swIphase2; //-v
  196. out->swIcPu = tmp_swIphase3;
  197. break;
  198. case 3:
  199. out->swIaPu = tmp_swIphase1; // u
  200. out->swIcPu = tmp_swIphase2; //-w
  201. out->swIbPu = tmp_swIphase3;
  202. break;
  203. case 4:
  204. out->swIcPu = tmp_swIphase1; // w
  205. out->swIaPu = tmp_swIphase2; //-u
  206. out->swIbPu = tmp_swIphase3;
  207. break;
  208. case 5:
  209. out->swIbPu = tmp_swIphase1; // v
  210. out->swIaPu = tmp_swIphase2; //-u
  211. out->swIcPu = tmp_swIphase3;
  212. break;
  213. case 6:
  214. out->swIcPu = tmp_swIphase1; // w
  215. out->swIbPu = tmp_swIphase2; //-v
  216. out->swIaPu = tmp_swIphase3;
  217. break;
  218. default:
  219. out->swIaPu = 0;
  220. out->swIbPu = 0;
  221. out->swIcPu = 0;
  222. break;
  223. }
  224. }
  225. else if(cp_stFlg.CurrentSampleModelSelect == RDSON)
  226. {
  227. SWORD tmp_swIphase1, tmp_swIphase2, tmp_swIphase3;
  228. out->uwIaReg = iAdc_GetResultPointer(1)[HW_ADC_IA_CH];
  229. out->uwIbReg = iAdc_GetResultPointer(1)[HW_ADC_IB_CH];
  230. out->uwIcReg = iAdc_GetResultPointer(1)[HW_ADC_IC_CH];
  231. tmp_swIphase1 = -(((SWORD)out->uwIaReg - cof->uwIaOffset) * cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
  232. tmp_swIphase2 = -(((SWORD)out->uwIbReg - cof->uwIbOffset) * cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
  233. tmp_swIphase3 = -(((SWORD)out->uwIcReg - cof->uwIcOffset) * cof->uwCurReg2Pu >> 10); // Q14=Q24-Q10
  234. switch (pwm_stGenOut.uwSampleArea)
  235. {
  236. case IgnoreNone:
  237. out->swIaPu = tmp_swIphase1;
  238. out->swIbPu = tmp_swIphase2;
  239. out->swIcPu = tmp_swIphase3;
  240. break;
  241. case IgnoreA:
  242. out->swIaPu = -tmp_swIphase2 - tmp_swIphase3;
  243. out->swIbPu = tmp_swIphase2;
  244. out->swIcPu = tmp_swIphase3;
  245. break;
  246. case IgnoreB:
  247. out->swIaPu = tmp_swIphase1;
  248. out->swIbPu = -tmp_swIphase1 - tmp_swIphase3;
  249. out->swIcPu = tmp_swIphase3;
  250. break;
  251. case IgnoreC:
  252. out->swIaPu = tmp_swIphase1;
  253. out->swIbPu = tmp_swIphase2;
  254. out->swIcPu = tmp_swIphase3;
  255. break;
  256. case IgnoreAB:
  257. out->swIaPu = -tmp_swIphase3 >> 1;
  258. out->swIbPu = -tmp_swIphase3 >> 1;
  259. out->swIcPu = tmp_swIphase3;
  260. break;
  261. case IgnoreBC:
  262. out->swIaPu = tmp_swIphase1;
  263. out->swIbPu = -tmp_swIphase1 >> 1;
  264. out->swIcPu = -tmp_swIphase1 >> 1;
  265. break;
  266. case IgnoreAC:
  267. out->swIaPu = -tmp_swIphase2 >> 1;
  268. out->swIbPu = tmp_swIphase2;
  269. out->swIcPu = -tmp_swIphase2 >> 1;
  270. break;
  271. default:
  272. break;
  273. }
  274. }*/
  275. else
  276. {
  277. //do nothing
  278. }
  279. /* Current absolute value & max value */
  280. if ((out->swIaPu) >= 0)
  281. {
  282. out->uwIaAbsPu = (UWORD)out->swIaPu;
  283. }
  284. else
  285. {
  286. out->uwIaAbsPu = (UWORD)(-(out->swIaPu));
  287. }
  288. if ((out->swIbPu) >= 0)
  289. {
  290. out->uwIbAbsPu = (UWORD)out->swIbPu;
  291. }
  292. else
  293. {
  294. out->uwIbAbsPu = (UWORD)(-(out->swIbPu));
  295. }
  296. if ((out->swIcPu) >= 0)
  297. {
  298. out->uwIcAbsPu = (UWORD)out->swIcPu;
  299. }
  300. else
  301. {
  302. out->uwIcAbsPu = (UWORD)(-(out->swIcPu));
  303. }
  304. uwIpeakPu = out->uwIaAbsPu > out->uwIbAbsPu ? out->uwIaAbsPu : out->uwIbAbsPu;
  305. uwIpeakPu = out->uwIcAbsPu > uwIpeakPu ? out->uwIcAbsPu : uwIpeakPu;
  306. out->uwIpeakPu = uwIpeakPu;
  307. }
  308. void adc_voSampleUp(const ADC_COF *cof, ADC_UP_OUT *out)
  309. {
  310. /* Register value */
  311. out->uwVdcReg = iAdc_GetResultPointer(0)[HW_ADC_UDC_CH];
  312. out->uwU6VReg = iAdc_GetResultPointer(0)[HW_ADC_U6V_CH];
  313. out->uwU5VReg = iAdc_GetResultPointer(0)[HW_ADC_U5V_CH];
  314. out->PCBTempReg = iAdc_GetResultPointer(0)[HW_ADC_PCBTEMP_CH];
  315. out->TorqTempReg = iAdc_GetResultPointer(0)[HW_ADC_MOTTEMP_CH];
  316. out->uwU12VReg = iAdc_GetResultPointer(0)[HW_ADC_U12V_CH];
  317. out->uwThrottleReg = iAdc_GetResultPointer(0)[HW_ADC_THRO_CH];
  318. out->uwVdcPu = (UWORD)((ULONG)out->uwVdcReg * cof->uwVdcReg2Pu >> 10); // Q14=Q24-Q10
  319. //out->uwVdcPu = (SLONG)((out->uwVdcReg * cof->uwVdcReg2Pu >> 10) - 410); // Q14=Q24-Q10,电路上DCDC的EN漏电流导致测量偏高1.2V
  320. /* Vdc LPF */
  321. out->uwVdcLpfPu = ((out->uwVdcPu - out->uwVdcLpfPu) >> 1) + out->uwVdcLpfPu;
  322. out->uwU6VPu = (UWORD)((ULONG)out->uwU6VReg * cof->uwU6VReg2Pu >> 10); // Q14=Q24-Q10;
  323. out->uwU5VPu = (UWORD)((ULONG)out->uwU5VReg * cof->uwU5VReg2Pu >> 10); // Q14=Q24-Q10;
  324. out->uwU12VPu = (UWORD)((ULONG)out->uwU12VReg * cof->uwU12VReg2Pu >> 10); // Q14=Q24-Q10;
  325. out->MotorTempR = out->MotorTempReg * cof->swMotorTempKcof >> 10; // Q14=Q24-Q10;
  326. ////////////////// Single Resitance Current Sample//////////////////////////////////////////////////////
  327. if (pwm_stGenOut.blSampleCalibFlag == TRUE)
  328. {
  329. switch (pwm_stGenOut.uwSingelRSampleArea)
  330. {
  331. case 0:
  332. out->swCalibIaPu = 0;
  333. out->swCalibIbPu = 0;
  334. out->swCalibIcPu = 0;
  335. break;
  336. case SampleA:
  337. out->swCalibIaPu = -(SWORD)((((SWORD)iAdc_GetResultPointer(2)[HW_ADC_IDC_CH] - (SWORD)cof->uwIdcOffset) * (SLONG)cof->uwCurIdcReg2Pu) >> 10); // Q14=Q24-Q10
  338. break;
  339. case SampleB:
  340. out->swCalibIbPu = -(SWORD)((((SWORD)iAdc_GetResultPointer(2)[HW_ADC_IDC_CH] - (SWORD)cof->uwIdcOffset) * (SLONG)cof->uwCurIdcReg2Pu) >> 10); // Q14=Q24-Q10
  341. break;
  342. case SampleC:
  343. out->swCalibIcPu = -(SWORD)((((SWORD)iAdc_GetResultPointer(2)[HW_ADC_IDC_CH] - (SWORD)cof->uwIdcOffset) * (SLONG)cof->uwCurIdcReg2Pu) >> 10); // Q14=Q24-Q10
  344. break;
  345. default:
  346. break;
  347. }
  348. }
  349. ////////////////// PCB TEMP//////////////////////////////////////////////////////
  350. if(out->PCBTempReg != 0)
  351. {
  352. out->PCBTempR = (UWORD)((ULONG)4096 * PCB_TEMP_SAMPLER / out->PCBTempReg - PCB_TEMP_SAMPLER); // Q14=Q24-Q10;
  353. }
  354. PcbTempCal((SWORD)out->PCBTempR);
  355. out->PCBTemp = tmp_PcbTemp;
  356. }
  357. static SWORD adc_pvt_swSingleReg = 0;
  358. static SLONG adc_pvt_slRdsonReg = 0;
  359. static LPF_OUT adc_pvt_stRdsonCoefLpf = {.slY.sw.hi = 1024, .slY.sw.low = 0};
  360. static BOOL adc_pvt_blCalGainFlg = FALSE;
  361. static ULONG adc_pvt_ulGainTemp1 = 0;
  362. static ULONG adc_pvt_ulIaAbsPu, adc_pvt_ulIbAbsPu, adc_pvt_ulIcAbsPu, adc_pvt_ulIPeakPu;
  363. void adc_voSRCalibration(ADC_COF *cof, const ADC_UP_OUT *up_out, ADC_DOWN_OUT *down_out)
  364. {
  365. if (pwm_stGenOut.blSampleCalibFlag == TRUE)
  366. {
  367. switch (pwm_stGenOut.uwSingelRSampleArea)
  368. {
  369. case 0:
  370. break;
  371. case SampleA:
  372. if(adc_pvt_swSingleReg > up_out->swCalibIaPu)
  373. {
  374. adc_pvt_swSingleReg = up_out->swCalibIaPu;
  375. }
  376. if(adc_pvt_slRdsonReg > down_out->slSampIaPu)
  377. {
  378. adc_pvt_slRdsonReg = down_out->slSampIaPu;
  379. }
  380. break;
  381. case SampleB:
  382. if(adc_pvt_swSingleReg > up_out->swCalibIbPu)
  383. {
  384. adc_pvt_swSingleReg = up_out->swCalibIbPu;
  385. }
  386. if(adc_pvt_slRdsonReg > down_out->slSampIbPu)
  387. {
  388. adc_pvt_slRdsonReg = down_out->slSampIbPu;
  389. }
  390. break;
  391. case SampleC:
  392. if(adc_pvt_swSingleReg > up_out->swCalibIcPu)
  393. {
  394. adc_pvt_swSingleReg = up_out->swCalibIcPu;
  395. }
  396. if(adc_pvt_slRdsonReg > down_out->slSampIcPu)
  397. {
  398. adc_pvt_slRdsonReg = down_out->slSampIcPu;
  399. }
  400. break;
  401. default:
  402. break;
  403. }
  404. adc_pvt_blCalGainFlg = TRUE;
  405. }
  406. else
  407. {
  408. ULONG ulOverflowCurPu = (ULONG)(4095 - cof->uwIaOffset) * cof->uwCurReg2Pu >> 10;
  409. if(scm_uwSpdFbkLpfAbsPu < 2500)
  410. {
  411. adc_pvt_ulIaAbsPu = ABS(down_out->slSampIaPu);
  412. adc_pvt_ulIbAbsPu = ABS(down_out->slSampIbPu);
  413. adc_pvt_ulIcAbsPu = ABS(down_out->slSampIcPu);
  414. adc_pvt_ulIPeakPu = adc_pvt_ulIaAbsPu > adc_pvt_ulIbAbsPu ? adc_pvt_ulIaAbsPu : adc_pvt_ulIbAbsPu;
  415. down_out->ulISamplePeakPu = adc_pvt_ulIcAbsPu > adc_pvt_ulIPeakPu ? adc_pvt_ulIcAbsPu : adc_pvt_ulIPeakPu;
  416. if(down_out->ulISamplePeakPu > 32767)
  417. {
  418. adc_pvt_ulGainTemp1 = 780; ///< Rdson电流采样溢出SWORD时校准系数需小于1024
  419. adc_pvt_stRdsonCoefLpf.slY.sw.hi = (SWORD)adc_pvt_ulGainTemp1; ///< 系数立刻变化,不经过滤波,防止down_out->swIaPu溢出
  420. }
  421. // else if(down_out->ulISamplePeakPu > 25800) ///< 25800 = 32767 / (1300 / 1024)
  422. // {
  423. // adc_pvt_ulGainTemp1 = 1024;
  424. // adc_pvt_stRdsonCoefLpf.slY.sw.hi = (SWORD)adc_pvt_ulGainTemp1;
  425. // }
  426. else
  427. {
  428. adc_pvt_ulGainTemp1 = 1024; ///< 允许其他数值,但大于1024需注意溢出SWORD
  429. }
  430. cof->blCalibCalFlag = FALSE;
  431. adc_pvt_blCalGainFlg = FALSE;
  432. }
  433. else
  434. {
  435. if(adc_pvt_blCalGainFlg)
  436. {
  437. if(adc_pvt_slRdsonReg != 0 && ABS(adc_pvt_slRdsonReg) < ulOverflowCurPu)
  438. {
  439. adc_pvt_ulGainTemp1 = (SLONG)((SLONG)adc_pvt_swSingleReg << 10) / (SLONG)adc_pvt_slRdsonReg;
  440. }
  441. else if(ABS(adc_pvt_slRdsonReg) >= ulOverflowCurPu)
  442. {
  443. adc_pvt_ulGainTemp1 = 780; ///< Rdson电流采样削顶时不再校准电流,强制输出为119A防止溢出,尽快报出过流故障
  444. adc_pvt_stRdsonCoefLpf.slY.sw.hi = (SWORD)adc_pvt_ulGainTemp1;
  445. }
  446. else
  447. {
  448. // do nothing
  449. }
  450. if(adc_pvt_ulGainTemp1 > cof->uwCalibcoefMax)
  451. {
  452. adc_pvt_ulGainTemp1 = cof->uwCalibcoefMax;
  453. }
  454. else if(adc_pvt_ulGainTemp1 < cof->uwCalibcoefMin)
  455. {
  456. adc_pvt_ulGainTemp1 = cof->uwCalibcoefMin;
  457. }
  458. else
  459. {
  460. //do nothing
  461. }
  462. cof->blCalibCalFlag = TRUE;
  463. adc_pvt_blCalGainFlg = FALSE;
  464. }
  465. else
  466. {
  467. adc_pvt_swSingleReg = 0;
  468. adc_pvt_slRdsonReg = 0;
  469. }
  470. }
  471. mth_voLPFilter((SWORD)adc_pvt_ulGainTemp1, &adc_pvt_stRdsonCoefLpf);
  472. cof->uwCalibcoef = adc_pvt_stRdsonCoefLpf.slY.sw.hi;
  473. }
  474. }
  475. /***************************************************************
  476. Function: adc_voSampleCoef;
  477. Description: Get other A/D sample value
  478. Call by: functions in Mainloop;
  479. Input Variables: ADCIABFIXCOF
  480. Output/Return Variables: ADCTESTOUT
  481. Subroutine Call:
  482. Reference: N/A
  483. ****************************************************************/
  484. void adc_voSampleCoef(ADC_COF *cof)
  485. {
  486. cof->uwCurReg2Pu = ((UQWORD)ADC_IPHASE_CUR_MAX_AP << 24) / (1 << (ADC_RESOLUTION_BIT - 1)) / IBASE; // Q24
  487. cof->uwCurIdcReg2Pu = ((UQWORD)ADC_IDC_CUR_MAX_AP << 24) / (1 << (ADC_RESOLUTION_BIT)) / IBASE; // Q24
  488. cof->uwVdcReg2Pu = ((UQWORD)ADC_VDC_MAX_VT << 24) / (1 << ADC_RESOLUTION_BIT) / VBASE; // Q24
  489. cof->uwUabcReg2Pu = ((UQWORD)ADC_UABC_MAX_VT << 24) / (1 << (ADC_RESOLUTION_BIT)) / VBASE; // Q24
  490. cof->uwU6VReg2Pu = ((UQWORD)ADC_LIGHT_MAX_VT << 24) / (1 << (ADC_RESOLUTION_BIT)) / VBASE; // Q24;
  491. cof->uwU5VReg2Pu = ((UQWORD)ADC_SPDSENSOR_MAX_VT << 24) / (1 << (ADC_RESOLUTION_BIT)) / VBASE; // Q24;
  492. cof->uwU12VReg2Pu = ((UQWORD)ADC_DISPLAY_MAX_VT << 24) / (1 << (ADC_RESOLUTION_BIT)) / VBASE; // Q24;
  493. cof->uwCalibcoef = 1024;
  494. cof->uwCalibcoefMax = 2048;
  495. cof->uwCalibcoefMin = 200;
  496. cof->uwCalibCoefK = 160; // q10
  497. mth_voLPFilterCoef(1000000 / 30, FTBC_HZ, &adc_pvt_stRdsonCoefLpf.uwKx); //100Hz
  498. }
  499. /***************************************************************
  500. Function: adc_voSampleInit;
  501. Description: ADC sample initialization
  502. Call by: mn_voSoftwareInit;
  503. Input Variables: N/A
  504. Output/Return Variables: N/A
  505. Subroutine Call:
  506. Reference: N/A
  507. ****************************************************************/
  508. void adc_voSampleInit(void)
  509. {
  510. adc_stDownOut.swIaPu = 0;
  511. adc_stDownOut.swIbPu = 0;
  512. adc_stDownOut.swIcPu = 0;
  513. adc_stDownOut.uwIaAbsPu = 0;
  514. adc_stDownOut.uwIbAbsPu = 0;
  515. adc_stDownOut.uwIcAbsPu = 0;
  516. adc_stDownOut.uwIpeakPu = 0;
  517. adc_stDownOut.uwIaReg = 0;
  518. adc_stDownOut.uwIbReg = 0;
  519. adc_stDownOut.uwIcReg = 0;
  520. adc_stDownOut.uwFirstCurREG = 0;
  521. adc_stDownOut.uwSecondCurREG = 0;
  522. adc_stDownOut.uwADCSector = 0;
  523. adc_stDownOut.uwIaAvgPu = 0;
  524. adc_stDownOut.uwIbAvgPu = 0;
  525. adc_stDownOut.uwIcAvgPu = 0;
  526. adc_stDownOut.ulUaRegSum = 0;
  527. adc_stDownOut.ulUbRegSum = 0;
  528. adc_stDownOut.ulUcRegSum = 0;
  529. adc_stDownOut.ulIdcRegSum = 0;
  530. adc_stDownOut.ulIaRegSum = 0;
  531. adc_stDownOut.ulIbRegSum = 0;
  532. adc_stDownOut.ulIcRegSum = 0;
  533. adc_stDownOut.uwADCCalibCt = 0;
  534. adc_stDownOut.blADCCalibFlg = FALSE;
  535. adc_stDownOut.ulISamplePeakPu = 0;
  536. adc_stUpOut.uwVdcPu = 0;
  537. adc_stUpOut.uwVdcLpfPu = 0;
  538. adc_stUpOut.uwU6VPu = 0;
  539. adc_stUpOut.uwU5VPu = 0;
  540. adc_stUpOut.uwU12VPu = 0;
  541. adc_stUpOut.uwTrottlePu = 0;
  542. adc_stUpOut.PCBTemp = 0;
  543. adc_stUpOut.MotorTemp = 0;
  544. adc_stUpOut.uwVdcReg = 0;
  545. adc_stUpOut.uwU6VReg = 0;
  546. adc_stUpOut.uwU5VReg = 0;
  547. adc_stUpOut.uwU12VReg = 0;
  548. adc_stUpOut.uwThrottleReg = 0;
  549. adc_stUpOut.PCBTempReg = 0;
  550. adc_stUpOut.MotorTempReg = 0;
  551. adc_stUpOut.swCalibIaPu = 0;
  552. adc_stUpOut.swCalibIbPu = 0;
  553. adc_stUpOut.swCalibIcPu = 0;
  554. adc_stUpOut.uwADCCalibCt = 0;
  555. adc_stUpOut.blADCCalibFlg = FALSE;
  556. adc_stUpOut.swIPMTempCe = 0;
  557. adc_pvt_swSingleReg = 0;
  558. adc_pvt_slRdsonReg = 0;
  559. adc_pvt_stRdsonCoefLpf.slY.sw.hi = 1024;
  560. adc_pvt_stRdsonCoefLpf.slY.sw.low = 0;
  561. adc_pvt_blCalGainFlg = FALSE;
  562. adc_pvt_ulGainTemp1 = 0;
  563. adc_pvt_ulIaAbsPu = 0;
  564. adc_pvt_ulIbAbsPu = 0;
  565. adc_pvt_ulIcAbsPu = 0;
  566. adc_pvt_ulIPeakPu = 0;
  567. }
  568. /*************************************************************************
  569. Local Functions (N/A)
  570. *************************************************************************/
  571. /************************************************************************
  572. Copyright (c) 2018 Welling Motor Technology(Shanghai) Co. Ltd.
  573. All rights reserved.
  574. *************************************************************************/
  575. #ifdef _ADCDRV_C_
  576. #undef _ADCDRV_C_
  577. #endif
  578. /*************************************************************************
  579. End of this File (EOF)!
  580. Do not put anything after this part!
  581. *************************************************************************/