1 /**
2 ******************************************************************************
3 * @file lib_LoadNVR.c
4 * @author Application Team
5 * @version V1.1.0
6 * @date 2019-10-28
7 * @brief Load information from NVR.
8 ******************************************************************************
9 * @attention
10 *
11 ******************************************************************************
12 */
13
14 /* Includes ------------------------------------------------------------------*/
15 #include "lib_LoadNVR.h"
16
17
18 /**
19 * @breif Loads Analog trim data from NVR manually.
20 * @note Successful Operation:
21 * - Load [0x80DC0] or [0x80DD0] to ANA registers(B C D E)
22 * - Load [0x80DE0] or [0x80DE8] to ANA registers(10)
23 * @param None
24 * @retval 0: Function succeeded.
25 !0: Function failed.
26 bit[0]=1: Function failed(ANA registers(B C D E) Checksum error).
27 bit[1]=1: Function failed(ANA registers(10) Checksum error).
28 */
NVR_LoadANADataManual(void)29 uint32_t NVR_LoadANADataManual(void)
30 {
31 uint32_t checksum;
32 uint32_t op_reg;
33 uint32_t ana_data;
34 uint32_t key_reg = 0xFFFFFFFF;
35 uint32_t ret = 0;
36
37 /* Get Analog data1 */
38 ana_data = *NVR_ANA_TRIMDATA1;
39 op_reg = *NVR_ANA_OPREG1;
40 /* Calculate checksum1 */
41 checksum = ~(ana_data + op_reg + key_reg);
42 /* Compare checksum1 */
43 if (checksum == (*NVR_ANA_CHECKSUM1))
44 {
45 ANA->REGB = (uint8_t)(ana_data);
46 ANA->REGC = (uint8_t)(ana_data >> 8);
47 ANA->REGD = (uint8_t)(ana_data >> 16);
48 ANA->REGE = (uint8_t)(ana_data >> 24);
49 }
50 else
51 {
52 /* Get Analog data2 */
53 ana_data = *NVR_ANA_TRIMDATA2;
54 op_reg = *NVR_ANA_OPREG2;
55 /* Calculate checksum2 */
56 checksum = ~(ana_data + op_reg + key_reg);
57 /* Compare checksum2 */
58 if (checksum == (*NVR_ANA_CHECKSUM2))
59 {
60 ANA->REGB = (uint8_t)(ana_data);
61 ANA->REGC = (uint8_t)(ana_data >> 8);
62 ANA->REGD = (uint8_t)(ana_data >> 16);
63 ANA->REGE = (uint8_t)(ana_data >> 24);
64 }
65 else
66 {
67 ret |= BIT0;
68 }
69 }
70
71 /* Get Analog data1 */
72 ana_data = *NVR_ANA1_REG10;
73 /* Calculate checksum1 */
74 checksum = ~ana_data;
75 /* Compare checksum1 */
76 if (checksum == (*NVR_ANA1_REG10_CHKSUM))
77 {
78 ANA->REG10 = (uint8_t)(ana_data);
79 }
80 else
81 {
82 /* Get Analog data2 */
83 ana_data = *NVR_ANA2_REG10;
84 /* Calculate checksum2 */
85 checksum = ~ana_data;
86 /* Compare checksum2 */
87 if (checksum == (*NVR_ANA2_REG10_CHKSUM))
88 {
89 ANA->REG10 = (uint8_t)(ana_data);
90 }
91 else
92 {
93 ret |= BIT1;
94 }
95 }
96
97 return ret;
98 }
99
100 /**
101 * @breif Gets the parameters of ADC voltage measuring.
102 * @note Voltage(unit:V) = aParameter*ADC_DATA + bParameter + OffsetParameter
103 * ADC_DATA: ADC channel original data
104 * aParameter/bParameter/OffsetParameter: Get from this function
105 * @param [in]Mode:
106 * NVR_3V_EXTERNAL_NODIV
107 * NVR_3V_EXTERNAL_RESDIV
108 * NVR_3V_BAT1_RESDIV
109 * NVR_3V_BATRTC_RESDIV
110 * NVR_5V_EXTERNAL_NODIV
111 * NVR_5V_EXTERNAL_RESDIV
112 * NVR_5V_BAT1_RESDIV
113 * NVR_5V_BATRTC_RESDIV
114 * @param [out]Parameter: The parameters get from NVR
115 * @retval 0: Function succeeded.
116 1: Function failed(Checksum error).
117 */
NVR_GetVoltageParameters(uint32_t Mode,NVR_ADCVOLPARA * Parameter)118 uint32_t NVR_GetVoltageParameters(uint32_t Mode, NVR_ADCVOLPARA *Parameter)
119 {
120 uint32_t checksum;
121 uint32_t i;
122 int32_t tmp_int;
123
124 /* Check the parameters */
125 assert_parameters(IS_NVR_ADCVOL_MODE(Mode));
126
127 /*----- Power supply: 5V -----*/
128 if (0x100UL & Mode)
129 {
130 /* Parameter */
131 checksum = 0UL;
132 for (i=0; i<8; i++)
133 checksum += *(NVR_5VPARA_BASEADDR1+i);
134 checksum = ~(checksum);
135 if (checksum != *(NVR_5VPARA_BASEADDR1+i)) /* Checksum1 error */
136 {
137 checksum = 0UL;
138 for (i=0; i<8; i++)
139 checksum += *(NVR_5VPARA_BASEADDR2+i);
140 checksum = ~(checksum);
141 if (checksum != *(NVR_5VPARA_BASEADDR2+i)) /* Checksum2 error */
142 {
143 return 1;
144 }
145 else
146 {
147 tmp_int = (int32_t)*(NVR_5VPARA_BASEADDR2+2*(Mode-0x100UL));
148 Parameter->aParameter = (float)(tmp_int / 100000.0);
149 tmp_int = (int32_t)*(NVR_5VPARA_BASEADDR2+2*(Mode-0x100UL)+1);
150 Parameter->bParameter = (float)(tmp_int / 100000.0);
151 }
152 }
153 else
154 {
155 tmp_int = (int32_t)*(NVR_5VPARA_BASEADDR1+2*(Mode-0x100UL));
156 Parameter->aParameter = (float)(tmp_int / 100000.0);
157 tmp_int = (int32_t)*(NVR_5VPARA_BASEADDR1+2*(Mode-0x100UL)+1);
158 Parameter->bParameter = (float)(tmp_int / 100000.0);
159 }
160 /* Offset */
161 /* Calculate checksum1 */
162 checksum = 0UL;
163 for (i = 0; i < 4; i++)
164 checksum += *(NVR_5VADCCHx_NODIV1 + i);
165 checksum = ~(checksum);
166 if (checksum != *(NVR_5VADCCHx_NODIV1 + i))
167 {
168 /* Calculate checksum2 */
169 checksum = 0UL;
170 for (i = 0; i < 4; i++)
171 checksum += *(NVR_5VADCCHx_NODIV2+i);
172 checksum = ~(checksum);
173 if (checksum != *(NVR_5VADCCHx_NODIV2 + i))
174 {
175 return 1;
176 }
177 else
178 {
179 Parameter->OffsetParameter = (float)((int32_t)*(NVR_5VADCCHx_NODIV2 + (Mode-0x100UL)));
180 return 0;
181 }
182 }
183 else
184 {
185 Parameter->OffsetParameter = (float)((int32_t)*(NVR_5VADCCHx_NODIV1 + (Mode-0x100UL)));
186 return 0;
187 }
188 }
189 /*----- Power supply: 3.3V -----*/
190 else
191 {
192 checksum = 0UL;
193 for (i=0; i<8; i++)
194 checksum += *(NVR_3VPARA_BASEADDR1+i);
195 checksum = ~(checksum);
196 if (checksum != *(NVR_3VPARA_BASEADDR1+i)) /* Checksum1 error */
197 {
198 checksum = 0UL;
199 for (i=0; i<8; i++)
200 checksum += *(NVR_3VPARA_BASEADDR2+i);
201 checksum = ~(checksum);
202 if (checksum != *(NVR_3VPARA_BASEADDR2+i)) /* Checksum2 error */
203 {
204 return 1;
205 }
206 else
207 {
208 tmp_int = (int32_t)*(NVR_3VPARA_BASEADDR2+2*(Mode));
209 Parameter->aParameter = (float)(tmp_int / 100000.0);
210 tmp_int = (int32_t)*(NVR_3VPARA_BASEADDR2+2*(Mode)+1);
211 Parameter->bParameter = (float)(tmp_int / 100000.0);
212 }
213 }
214 else
215 {
216 tmp_int = (int32_t)*(NVR_3VPARA_BASEADDR1+2*(Mode));
217 Parameter->aParameter = (float)(tmp_int / 100000.0);
218 tmp_int = (int32_t)*(NVR_3VPARA_BASEADDR1+2*(Mode)+1);
219 Parameter->bParameter = (float)(tmp_int / 100000.0);
220 }
221 /* Calculate checksum1 */
222 checksum = 0UL;
223 for (i = 0; i < 4; i++)
224 checksum += *(NVR_3VADCCHx_NODIV1 + i);
225 checksum = ~(checksum);
226 if (checksum != *(NVR_3VADCCHx_NODIV1 + i))
227 {
228 /* Calculate checksum2 */
229 checksum = 0UL;
230 for (i = 0; i < 4; i++)
231 checksum += *(NVR_3VADCCHx_NODIV2+i);
232 checksum = ~(checksum);
233 if (checksum != *(NVR_3VADCCHx_NODIV2 + i))
234 {
235 return 1;
236 }
237 else
238 {
239 Parameter->OffsetParameter = (float)((int32_t)*(NVR_3VADCCHx_NODIV2 + (Mode)));
240 return 0;
241 }
242 }
243 else
244 {
245 Parameter->OffsetParameter = (float)((int32_t)*(NVR_3VADCCHx_NODIV1 + (Mode)));
246 return 0;
247 }
248 }
249 }
250
251 /**
252 * @breif Gets RTC parameters(P0 P1 P2).
253 * @param [out]TempParams The pointer to struct NVR_TempParams.
254 * @retval 0: Function succeeded.
255 !0: Function failed.
256 bit[0]=1: Temperature Measure delta information checksum error, default value 0.
257 bit[1]=1: P0/P1/P2 paramters checksum error, default value 0
258 */
NVR_GetTempParameters(NVR_TempParams * TempParams)259 uint32_t NVR_GetTempParameters(NVR_TempParams *TempParams)
260 {
261 uint32_t checksum;
262 uint32_t data_u32[4];
263 int32_t TempDelta;
264 uint32_t retval = 0;
265
266 /*------------------------ Temperature Measure delta -------------------------*/
267 data_u32[0] = *NVR_REALTEMP1;
268 data_u32[1] = *NVR_MEATEMP1;
269 /* Calculate checksum1 */
270 checksum = ~(data_u32[0] + data_u32[1]);
271 if (checksum == (*NVR_TEMP_CHECKSUM1)) //checksum1 true
272 {
273 TempDelta = (int32_t)data_u32[0] - (int32_t)data_u32[1];
274 }
275 else
276 {
277 data_u32[0] = *NVR_REALTEMP2;
278 data_u32[1] = *NVR_MEATEMP2;
279 /* Calculate checksum2 */
280 checksum = ~(data_u32[0] + data_u32[1]);
281 if (checksum == (*NVR_TEMP_CHECKSUM2)) //checksum2 true
282 {
283 TempDelta = (int32_t)data_u32[0] - (int32_t)data_u32[1];
284 }
285 else
286 {
287 TempDelta = 0;
288 retval |= BIT0;
289 }
290 }
291 /*------------------------------ P parameters --------------------------------*/
292
293 data_u32[0] = *NVR_RTC1_P1_P0;
294 data_u32[1] = *NVR_RTC1_P2;
295 data_u32[2] = *NVR_RTC1_P5_P4;
296 data_u32[3] = *NVR_RTC1_P7_P6;
297
298 /* Calculate checksum1 */
299 checksum = ~(data_u32[0] + data_u32[1] + data_u32[2] + data_u32[3]);
300 if (checksum == (*NVR_RTC1_PCHECHSUM)) //checksum1 true
301 {
302 /* Get information */
303 TempParams->RTCTempP0 = (int16_t)(data_u32[0]);
304 TempParams->RTCTempP1 = (int16_t)(data_u32[0] >> 16);
305 TempParams->RTCTempP2 = (int32_t)((int32_t)(data_u32[1]) + (TempDelta*256));
306 }
307 else
308 {
309 data_u32[0] = *NVR_RTC2_P1_P0;
310 data_u32[1] = *NVR_RTC2_P2;
311 data_u32[2] = *NVR_RTC2_P5_P4;
312 data_u32[3] = *NVR_RTC2_P7_P6;
313 /* Calculate checksum2 */
314 checksum = ~(data_u32[0] + data_u32[1] + data_u32[2] + data_u32[3]);
315 if (checksum == (*NVR_RTC2_PCHECHSUM)) //checksum2 true
316 {
317 /* Get information */
318 TempParams->RTCTempP0 = (int16_t)(data_u32[0]);
319 TempParams->RTCTempP1 = (int16_t)(data_u32[0] >> 16);
320 TempParams->RTCTempP2 = (int32_t)((int32_t)(data_u32[1]) + (TempDelta*256));
321 }
322 else
323 {
324 /* Get information */
325 TempParams->RTCTempP0 = 0;
326 TempParams->RTCTempP1 = 0;
327 TempParams->RTCTempP2 = 0;
328 retval |= BIT1;
329 }
330 }
331 return retval;
332 }
333
334 /**
335 * @breif Loads RTC ACPx pramameters from NVR to RTC registers.
336 Get RTC pramameters.
337 * @param [out]RTCTempData The pointer to struct NVR_RTCINFO.
338 [in]DivCLKSource The RTC division output clock source frequency
339 * @retval 0: Function succeeded.
340 !0: Function not succeeded, load default value to registers.
341 bit[0]=1: Temperature Measure delta information checksum error, default value 0.
342 bit[1]=1: P paramters checksum error, default value 0
343 bit[2]=1: P4 checksum error, default value is 0
344 bit[3]=1: ACKx checksum error, default value 0
345 bit[4]=1: ACTI checksum error, default value is 0
346 bit[5]=1: ACKTEMP checksum error, defalut value is 0
347 */
NVR_GetInfo_LoadRTCData(NVR_RTCINFO * RTCTempData,uint32_t DivCLKSource)348 uint32_t NVR_GetInfo_LoadRTCData(NVR_RTCINFO *RTCTempData, uint32_t DivCLKSource)
349 {
350 uint32_t data_u32[5];
351 uint32_t checksum;
352 float pclk_mul;
353 uint32_t retval = 0;
354
355 /*------------------------ Temperature Measure delta -------------------------*/
356 data_u32[0] = *NVR_REALTEMP1;
357 data_u32[1] = *NVR_MEATEMP1;
358 /* Calculate checksum1 */
359 checksum = ~(data_u32[0] + data_u32[1]);
360 if (checksum == (*NVR_TEMP_CHECKSUM1)) //checksum1 true
361 {
362 RTCTempData->RTCTempDelta = (int32_t)data_u32[0] - (int32_t)data_u32[1];
363 }
364 else
365 {
366 data_u32[0] = *NVR_REALTEMP2;
367 data_u32[1] = *NVR_MEATEMP2;
368 /* Calculate checksum2 */
369 checksum = ~(data_u32[0] + data_u32[1]);
370 if (checksum == (*NVR_TEMP_CHECKSUM2)) //checksum2 true
371 {
372 RTCTempData->RTCTempDelta = (int32_t)data_u32[0] - (int32_t)data_u32[1];
373 }
374 else
375 {
376 RTCTempData->RTCTempDelta = 0;
377 retval |= BIT0;
378 }
379 }
380
381 /*------------------------------ P parameters --------------------------------*/
382 /* Wait until the RTC registers be synchronized */
383 RTC_WaitForSynchro();
384 /* Disable RTC Registers write-protection */
385 RTC_WriteProtection(DISABLE);
386
387 /* RTC div output clock source */
388 pclk_mul = DivCLKSource / 6553600.0;
389
390 data_u32[0] = *NVR_RTC1_P1_P0;
391 data_u32[1] = *NVR_RTC1_P2;
392 data_u32[2] = *NVR_RTC1_P5_P4;
393 data_u32[3] = *NVR_RTC1_P7_P6;
394 /* Calculate checksum1 */
395 checksum = ~(data_u32[0] + data_u32[1] + data_u32[2] + data_u32[3]);
396 if (checksum == (*NVR_RTC1_PCHECHSUM)) //checksum1 true
397 {
398 /* Get information */
399 RTCTempData->RTCTempP0 = (int16_t)(data_u32[0]);
400 RTCTempData->RTCTempP1 = (int16_t)(data_u32[0] >> 16);
401 RTCTempData->RTCTempP2 = (int32_t)((int32_t)(data_u32[1]) + (RTCTempData->RTCTempDelta*256));
402 RTCTempData->RTCTempP5 = (int16_t)(data_u32[2] >> 16);
403 RTCTempData->RTCTempP6 = (int16_t)(data_u32[3] * pclk_mul);
404 RTCTempData->RTCTempP7 = (int16_t)(data_u32[3] >> 16);
405
406 /* Load data to ACPx register */
407 RTC->ACP0 = (uint16_t)(data_u32[0] & 0xFFFF);
408 RTC->ACP1 = (uint16_t)((data_u32[0] >> 16) & 0xFFFF);
409 RTC->ACP2 = (uint32_t)((int32_t)(data_u32[1]) + (RTCTempData->RTCTempDelta*256));
410 RTC->ACP5 = (uint16_t)((data_u32[2] >> 16) & 0xFFFF);
411 RTC->ACP6 = ((uint16_t)((int16_t)(data_u32[3] * pclk_mul)));
412 RTC->ACP7 = (uint16_t)((data_u32[3] >> 16) & 0xFFFF);
413 }
414 else
415 {
416 data_u32[0] = *NVR_RTC2_P1_P0;
417 data_u32[1] = *NVR_RTC2_P2;
418 data_u32[2] = *NVR_RTC2_P5_P4;
419 data_u32[3] = *NVR_RTC2_P7_P6;
420 /* Calculate checksum2 */
421 checksum = ~(data_u32[0] + data_u32[1] + data_u32[2] + data_u32[3]);
422 if (checksum == (*NVR_RTC2_PCHECHSUM)) //checksum2 true
423 {
424 /* Get information */
425 RTCTempData->RTCTempP0 = (int16_t)(data_u32[0]);
426 RTCTempData->RTCTempP1 = (int16_t)(data_u32[0] >> 16);
427 RTCTempData->RTCTempP2 = (int32_t)((int32_t)(data_u32[1]) + (RTCTempData->RTCTempDelta*256));
428 RTCTempData->RTCTempP5 = (int16_t)(data_u32[2] >> 16);
429 RTCTempData->RTCTempP6 = (int16_t)(data_u32[3] * pclk_mul);
430 RTCTempData->RTCTempP7 = (int16_t)(data_u32[3] >> 16);
431
432 /* Load data to ACPx register */
433 RTC->ACP0 = (uint16_t)(data_u32[0] & 0xFFFF);
434 RTC->ACP1 = (uint16_t)((data_u32[0] >> 16) & 0xFFFF);
435 RTC->ACP2 = (uint32_t)((int32_t)(data_u32[1]) + (RTCTempData->RTCTempDelta*256));
436 RTC->ACP5 = (uint16_t)((data_u32[2] >> 16) & 0xFFFF);
437 RTC->ACP6 = (uint16_t)((int16_t)(data_u32[3] * pclk_mul));
438 RTC->ACP7 = (uint16_t)((data_u32[3] >> 16) & 0xFFFF);
439 }
440 else
441 {
442 /* Get information */
443 RTCTempData->RTCTempP0 = 0;
444 RTCTempData->RTCTempP1 = 0;
445 RTCTempData->RTCTempP2 = 0;
446 RTCTempData->RTCTempP5 = 0;
447 RTCTempData->RTCTempP6 = 0;
448 RTCTempData->RTCTempP7 = 0;
449 retval |= BIT1;
450 }
451 }
452
453 /*----------------------------------- P4 -------------------------------------*/
454 /* Calculate checksum1 */
455 data_u32[0] = *NVR_RTC1_P4;
456 checksum = ~data_u32[0];
457 if (checksum == (*NVR_RTC1_P4_CHKSUM))//checksum1 true
458 {
459 /* Get information */
460 RTCTempData->RTCTempP4 = (int16_t)data_u32[0];
461 RTC->ACP4 = data_u32[0];
462 }
463 else
464 {
465 data_u32[0] = *NVR_RTC2_P4;
466 checksum = ~data_u32[0];
467 if (checksum == (*NVR_RTC2_P4_CHKSUM))//checksum2 true
468 {
469 /* Get information */
470 RTCTempData->RTCTempP4 = (int16_t)data_u32[0];
471 RTC->ACP4 = data_u32[0];
472 }
473 else
474 {
475 RTCTempData->RTCTempP4 = 0;
476
477 retval |= BIT2;
478 }
479 }
480
481 /*-------------------------- RTC ACKx parameters -----------------------------*/
482 data_u32[0] = *NVR_RTC1_ACK0;
483 data_u32[1] = *NVR_RTC1_ACK1;
484 data_u32[2] = *NVR_RTC1_ACK2;
485 data_u32[3] = *NVR_RTC1_ACK3;
486 data_u32[4] = *NVR_RTC1_ACK4;
487 checksum = ~(data_u32[0] + data_u32[1] + data_u32[2] + data_u32[3] + data_u32[4]);
488 if (checksum == (*NVR_RTC1_ACK_CHKSUM))//checksum1 true
489 {
490 /* Get information */
491 RTCTempData->RTCTempK0 = data_u32[0];
492 RTCTempData->RTCTempK1 = data_u32[1];
493 RTCTempData->RTCTempK2 = data_u32[2];
494 RTCTempData->RTCTempK3 = data_u32[3];
495 RTCTempData->RTCTempK4 = data_u32[4];
496
497 /* Load data to ACKx register */
498 RTC->ACK[0] = data_u32[0];
499 RTC->ACK[1] = data_u32[1];
500 RTC->ACK[2] = data_u32[2];
501 RTC->ACK[3] = data_u32[3];
502 RTC->ACK[4] = data_u32[4];
503 }
504 else
505 {
506 data_u32[0] = *NVR_RTC2_ACK0;
507 data_u32[1] = *NVR_RTC2_ACK1;
508 data_u32[2] = *NVR_RTC2_ACK2;
509 data_u32[3] = *NVR_RTC2_ACK3;
510 data_u32[4] = *NVR_RTC2_ACK4;
511 checksum = ~(data_u32[0] + data_u32[1] + data_u32[2] + data_u32[3] + data_u32[4]);
512 if (checksum == (*NVR_RTC2_ACK_CHKSUM))//checksum2 true
513 {
514 /* Get information */
515 RTCTempData->RTCTempK0 = data_u32[0];
516 RTCTempData->RTCTempK1 = data_u32[1];
517 RTCTempData->RTCTempK2 = data_u32[2];
518 RTCTempData->RTCTempK3 = data_u32[3];
519 RTCTempData->RTCTempK4 = data_u32[4];
520
521 /* Load data to ACKx register */
522 RTC->ACK[0] = data_u32[0];
523 RTC->ACK[1] = data_u32[1];
524 RTC->ACK[2] = data_u32[2];
525 RTC->ACK[3] = data_u32[3];
526 RTC->ACK[4] = data_u32[4];
527 }
528 else
529 {
530 /* Get information */
531 RTCTempData->RTCTempK0 = 0;
532 RTCTempData->RTCTempK1 = 0;
533 RTCTempData->RTCTempK2 = 0;
534 RTCTempData->RTCTempK3 = 0;
535 RTCTempData->RTCTempK4 = 0;
536
537 retval |= BIT3;
538 }
539 }
540
541 /*-------------------------- RTC ACTI parameters -----------------------------*/
542 data_u32[0] = *NVR_RTC1_ACTI;
543 checksum = ~data_u32[0];
544 if (checksum == (*NVR_RTC1_ACTI_CHKSUM))
545 {
546 /* Get information */
547 RTCTempData->RTCACTI = data_u32[0];
548 /* Load data to ACKx register */
549 RTC->ACTI = data_u32[0];
550 }
551 else
552 {
553 data_u32[0] = *NVR_RTC2_ACTI;
554 checksum = ~data_u32[0];
555 if (checksum == (*NVR_RTC2_ACTI_CHKSUM))
556 {
557 /* Get information */
558 RTCTempData->RTCACTI = data_u32[0];
559 /* Load data to ACKx register */
560 RTC->ACTI = data_u32[0];
561 }
562 else
563 {
564 /* Get information */
565 RTCTempData->RTCACTI = 0;
566
567 retval |= BIT4;
568 }
569 }
570
571 /*------------------------- RTC ACKTemp parameters ---------------------------*/
572 data_u32[0] = *NVR_RTC1_ACKTEMP;
573 checksum = ~data_u32[0];
574 if (checksum == (*NVR_RTC1_ACKTEMP_CHKSUM))
575 {
576 /* Get information */
577 RTCTempData->RTCACKTemp = data_u32[0];
578 /* Load data to ACKx register */
579 RTC->ACKTEMP = data_u32[0];
580 }
581 else
582 {
583 data_u32[0] = *NVR_RTC2_ACKTEMP;
584 checksum = ~data_u32[0];
585 if (checksum == (*NVR_RTC2_ACKTEMP_CHKSUM))
586 {
587 /* Get information */
588 RTCTempData->RTCACKTemp = data_u32[0];
589 /* Load data to ACKx register */
590 RTC->ACKTEMP = data_u32[0];
591 }
592 else
593 {
594 /* Get information */
595 RTCTempData->RTCACKTemp = 0;
596
597 retval |= BIT5;
598 }
599 }
600 /*--------------------------------- ACF200 -----------------------------------*/
601 RTCTempData->RTCACF200 = (uint32_t)(int32_t)((pclk_mul * 0x320000));
602 RTC->ACF200 = (uint32_t)(int32_t)((pclk_mul * 0x320000));
603
604 /* Enable RTC Registers write-protection */
605 RTC_WriteProtection(ENABLE);
606 /* Wait until the RTC registers be synchronized */
607 RTC_WaitForSynchro();
608
609 return retval;
610 }
611
612 /**
613 * @breif Gets Power/Clock Measure result.
614 * @param [out]MEAResult The pointer to struct NVR_PWRMEARES.
615 * @retval 0: Function succeeded.
616 1: Function failed(Checksum error).
617 */
NVR_GetMISCGain(NVR_MISCGain * MEAResult)618 uint32_t NVR_GetMISCGain(NVR_MISCGain *MEAResult)
619 {
620 uint32_t avcc_data, dvcc_data, bgp_data, rcl_data, rch_data;
621 uint32_t checksum;
622
623 avcc_data = *NVR_AVCC_MEA1;
624 dvcc_data = *NVR_DVCC_MEA1;
625 bgp_data = *NVR_BGP_MEA1;
626 rcl_data = *NVR_RCL_MEA1;
627 rch_data = *NVR_RCH_MEA1;
628 /* Calculate checksum1 */
629 checksum = ~(avcc_data + dvcc_data + bgp_data + rcl_data + rch_data);
630 if (checksum == (*NVR_PWR_CHECKSUM1))
631 {
632 MEAResult->AVCCMEAResult = avcc_data;
633 MEAResult->DVCCMEAResult = dvcc_data;
634 MEAResult->BGPMEAResult = bgp_data;
635 MEAResult->RCLMEAResult = rcl_data;
636 MEAResult->RCHMEAResult = rch_data;
637 return 0;
638 }
639
640 avcc_data = *NVR_AVCC_MEA2;
641 dvcc_data = *NVR_DVCC_MEA2;
642 bgp_data = *NVR_BGP_MEA2;
643 rcl_data = *NVR_RCL_MEA2;
644 rch_data = *NVR_RCH_MEA2;
645 /* Calculate checksum2 */
646 checksum = ~(avcc_data + dvcc_data + bgp_data + rcl_data + rch_data);
647 if (checksum == (*NVR_PWR_CHECKSUM2))
648 {
649 MEAResult->AVCCMEAResult = avcc_data;
650 MEAResult->DVCCMEAResult = dvcc_data;
651 MEAResult->BGPMEAResult = bgp_data;
652 MEAResult->RCLMEAResult = rcl_data;
653 MEAResult->RCHMEAResult = rch_data;
654 return 0;
655 }
656 else
657 {
658 return 1;
659 }
660 }
661
662 /**
663 * @breif Gets Chip ID.
664 * @param [out]ChipID The pointer to struct NVR_CHIPID.
665 * @retval 0: Function succeeded.
666 1: Function failed(Checksum error).
667 */
NVR_GetChipID(NVR_CHIPID * ChipID)668 uint32_t NVR_GetChipID(NVR_CHIPID *ChipID)
669 {
670 uint32_t id0, id1;
671 uint32_t checksum;
672
673 id0 = *NVR_CHIP1_ID0;
674 id1 = *NVR_CHIP1_ID1;
675 /* Calculate checksum1 */
676 checksum = ~(id0 + id1);
677 if (checksum == (*NVR_CHIP1_CHECKSUM))
678 {
679 ChipID->ChipID0 = id0;
680 ChipID->ChipID1 = id1;
681 return 0;
682 }
683
684 id0 = *NVR_CHIP2_ID0;
685 id1 = *NVR_CHIP2_ID1;
686 /* Calculate checksum2 */
687 checksum = ~(id0 + id1);
688 if (checksum == (*NVR_CHIP2_CHECKSUM))
689 {
690 ChipID->ChipID0 = id0;
691 ChipID->ChipID1 = id1;
692 return 0;
693 }
694 else
695 {
696 return 1;
697 }
698 }
699
700 /*********************************** END OF FILE ******************************/
701