LibDriver NTC
Loading...
Searching...
No Matches
driver_ntc_read_test.c
Go to the documentation of this file.
1
36
37#include "driver_ntc_read_test.h"
38
39static ntc_handle_t gs_handle;
40
54uint8_t ntc_read_beta_formula_test(ntc_circuit_t circuit, float r_fixed_ohm,
55 float beta, float r25_ohm, ntc_filter_t filter, uint32_t times)
56{
57 uint8_t res;
58 uint32_t i;
59 ntc_info_t info;
60
61 /* link interface function */
62 DRIVER_NTC_LINK_INIT(&gs_handle, ntc_handle_t);
63 DRIVER_NTC_LINK_ADC_INIT(&gs_handle, ntc_interface_adc_init);
64 DRIVER_NTC_LINK_ADC_DEINIT(&gs_handle, ntc_interface_adc_deinit);
65 DRIVER_NTC_LINK_ADC_READ(&gs_handle, ntc_interface_adc_read);
66 DRIVER_NTC_LINK_DELAY_MS(&gs_handle, ntc_interface_delay_ms);
67 DRIVER_NTC_LINK_DEBUG_PRINT(&gs_handle, ntc_interface_debug_print);
68
69 /* get information */
70 res = ntc_info(&info);
71 if (res != 0)
72 {
73 ntc_interface_debug_print("ntc: get info failed.\n");
74
75 return 1;
76 }
77 else
78 {
79 /* print chip info */
80 ntc_interface_debug_print("ntc: chip is %s.\n", info.chip_name);
81 ntc_interface_debug_print("ntc: manufacturer is %s.\n", info.manufacturer_name);
82 ntc_interface_debug_print("ntc: interface is %s.\n", info.interface);
83 ntc_interface_debug_print("ntc: driver version is %d.%d.\n", info.driver_version / 1000, (info.driver_version % 1000) / 100);
84 ntc_interface_debug_print("ntc: min supply voltage is %0.1fV.\n", info.supply_voltage_min_v);
85 ntc_interface_debug_print("ntc: max supply voltage is %0.1fV.\n", info.supply_voltage_max_v);
86 ntc_interface_debug_print("ntc: max current is %0.2fmA.\n", info.max_current_ma);
87 ntc_interface_debug_print("ntc: max temperature is %0.1fC.\n", info.temperature_max);
88 ntc_interface_debug_print("ntc: min temperature is %0.1fC.\n", info.temperature_min);
89 }
90
91 /* init */
92 res = ntc_init(&gs_handle);
93 if (res != 0)
94 {
95 ntc_interface_debug_print("ntc: init failed.\n");
96
97 return 1;
98 }
99
100 /* start read test */
101 ntc_interface_debug_print("ntc: start read test.\n");
102
103 /* output */
104 if (circuit == NTC_CIRCUIT_VCC_NTC_R_GND)
105 {
106 ntc_interface_debug_print("ntc: circuit is vcc -> ntc -> r_fixed -> gnd.\n");
107 }
108 else
109 {
110 ntc_interface_debug_print("ntc: circuit is vcc -> r_fixed -> ntc -> gnd.\n");
111 }
112 ntc_interface_debug_print("ntc: circuit fixed resistor is %0.2f ohm.\n", r_fixed_ohm);
113 ntc_interface_debug_print("ntc: beta formula beta value is %0.2f.\n", beta);
114 ntc_interface_debug_print("ntc: beta formula r25 resistor is %0.2f ohm.\n", r25_ohm);
115 if (filter == NTC_FILTER_NONE)
116 {
117 ntc_interface_debug_print("ntc: filter is none.\n");
118 }
119 else if (filter == NTC_FILTER_FIRST_ORDER_LAG)
120 {
121 ntc_interface_debug_print("ntc: filter is first order lag.\n");
122 }
123 else if (filter == NTC_FILTER_MEDIAN)
124 {
125 ntc_interface_debug_print("ntc: filter is median.\n");
126 }
127 else if (filter == NTC_FILTER_ANTI_SPIKE_AVERAGE)
128 {
129 ntc_interface_debug_print("ntc: filter is anti spike average.\n");
130 }
131 else if (filter == NTC_FILTER_MOVING_AVERAGE)
132 {
133 ntc_interface_debug_print("ntc: filter is moving average.\n");
134 }
135 else if (filter == NTC_FILTER_WEIGHTED_MOVING_AVERAGE)
136 {
137 ntc_interface_debug_print("ntc: filter is weighted moving average.\n");
138 }
139 else if (filter == NTC_FILTER_LIMITING)
140 {
141 ntc_interface_debug_print("ntc: filter is limiting.\n");
142 }
143 else
144 {
145 ntc_interface_debug_print("ntc: filter is kalman.\n");
146 }
147
148 /* set circuit */
149 res = ntc_set_circuit(&gs_handle, circuit);
150 if (res != 0)
151 {
152 ntc_interface_debug_print("ntc: set circuit failed.\n");
153 (void)ntc_deinit(&gs_handle);
154
155 return 1;
156 }
157
158 /* set circuit fixed resistor */
159 res = ntc_set_circuit_fixed_resistor(&gs_handle, r_fixed_ohm);
160 if (res != 0)
161 {
162 ntc_interface_debug_print("ntc: set circuit fixed resistor failed.\n");
163 (void)ntc_deinit(&gs_handle);
164
165 return 1;
166 }
167
168 /* set algorithm beta formula */
169 res = ntc_set_algorithm(&gs_handle, NTC_ALGORITHM_BETA_FORMULA);
170 if (res != 0)
171 {
172 ntc_interface_debug_print("ntc: set algorithm failed.\n");
173 (void)ntc_deinit(&gs_handle);
174
175 return 1;
176 }
177
178 /* set algorithm beta formula beta value */
179 res = ntc_set_algorithm_beta_formula_beta_value(&gs_handle, beta);
180 if (res != 0)
181 {
182 ntc_interface_debug_print("ntc: set algorithm beta formula beta value failed.\n");
183 (void)ntc_deinit(&gs_handle);
184
185 return 1;
186 }
187
188 /* set algorithm beta formula r25 ohm */
189 res = ntc_set_algorithm_beta_formula_r25_ohm(&gs_handle, r25_ohm);
190 if (res != 0)
191 {
192 ntc_interface_debug_print("ntc: set algorithm beta formula r25 ohm failed.\n");
193 (void)ntc_deinit(&gs_handle);
194
195 return 1;
196 }
197
198 if (filter == NTC_FILTER_NONE)
199 {
200 /* set filter none */
201 res = ntc_set_filter(&gs_handle, NTC_FILTER_NONE);
202 if (res != 0)
203 {
204 ntc_interface_debug_print("ntc: set filter failed.\n");
205 (void)ntc_deinit(&gs_handle);
206
207 return 1;
208 }
209 }
210 else if (filter == NTC_FILTER_FIRST_ORDER_LAG)
211 {
212 /* set filter first order lag */
213 res = ntc_set_filter(&gs_handle, NTC_FILTER_FIRST_ORDER_LAG);
214 if (res != 0)
215 {
216 ntc_interface_debug_print("ntc: set filter failed.\n");
217 (void)ntc_deinit(&gs_handle);
218
219 return 1;
220 }
221
222 /* set filter first order lag 0.8 */
223 res = ntc_set_filter_first_order_lag(&gs_handle, 0.8f);
224 if (res != 0)
225 {
226 ntc_interface_debug_print("ntc: set filter first order lag failed.\n");
227 (void)ntc_deinit(&gs_handle);
228
229 return 1;
230 }
231
232 /* output */
233 ntc_interface_debug_print("ntc: first order lag filter alpha is %.02f.\n", 0.8f);
234 }
235 else if (filter == NTC_FILTER_MEDIAN)
236 {
237 /* set filter median */
238 res = ntc_set_filter(&gs_handle, NTC_FILTER_MEDIAN);
239 if (res != 0)
240 {
241 ntc_interface_debug_print("ntc: set filter failed.\n");
242 (void)ntc_deinit(&gs_handle);
243
244 return 1;
245 }
246
247 /* set filter median length 5 */
248 res = ntc_set_filter_median_length(&gs_handle, 5);
249 if (res != 0)
250 {
251 ntc_interface_debug_print("ntc: set filter median length failed.\n");
252 (void)ntc_deinit(&gs_handle);
253
254 return 1;
255 }
256
257 /* output */
258 ntc_interface_debug_print("ntc: median filter length is %d.\n", 5);
259 }
260 else if (filter == NTC_FILTER_ANTI_SPIKE_AVERAGE)
261 {
262 /* set filter anti spike average */
263 res = ntc_set_filter(&gs_handle, NTC_FILTER_ANTI_SPIKE_AVERAGE);
264 if (res != 0)
265 {
266 ntc_interface_debug_print("ntc: set filter failed.\n");
267 (void)ntc_deinit(&gs_handle);
268
269 return 1;
270 }
271
272 /* set filter anti spike average length 5 */
273 res = ntc_set_filter_anti_spike_average_length(&gs_handle, 5);
274 if (res != 0)
275 {
276 ntc_interface_debug_print("ntc: set filter anti spike average length failed.\n");
277 (void)ntc_deinit(&gs_handle);
278
279 return 1;
280 }
281
282 /* output */
283 ntc_interface_debug_print("ntc: anti spike average filter length is %d.\n", 5);
284 }
285 else if (filter == NTC_FILTER_MOVING_AVERAGE)
286 {
287 /* set filter moving average */
288 res = ntc_set_filter(&gs_handle, NTC_FILTER_MOVING_AVERAGE);
289 if (res != 0)
290 {
291 ntc_interface_debug_print("ntc: set filter failed.\n");
292 (void)ntc_deinit(&gs_handle);
293
294 return 1;
295 }
296
297 /* set filter moving average length 5 */
298 res = ntc_set_filter_moving_average_length(&gs_handle, 5);
299 if (res != 0)
300 {
301 ntc_interface_debug_print("ntc: set filter moving average length failed.\n");
302 (void)ntc_deinit(&gs_handle);
303
304 return 1;
305 }
306
307 /* output */
308 ntc_interface_debug_print("ntc: moving average filter length is %d.\n", 5);
309 }
310 else if (filter == NTC_FILTER_WEIGHTED_MOVING_AVERAGE)
311 {
312 float weight[] = {1.0, 2.0f, 3.0f, 4.0f, 5.0f};
313
314 /* set filter weighted moving average */
315 res = ntc_set_filter(&gs_handle, NTC_FILTER_WEIGHTED_MOVING_AVERAGE);
316 if (res != 0)
317 {
318 ntc_interface_debug_print("ntc: set filter failed.\n");
319 (void)ntc_deinit(&gs_handle);
320
321 return 1;
322 }
323
324 /* set filter weighted moving average length 5 */
325 res = ntc_set_filter_weighted_moving_average_length(&gs_handle, weight, 5);
326 if (res != 0)
327 {
328 ntc_interface_debug_print("ntc: set filter weighted moving average length failed.\n");
329 (void)ntc_deinit(&gs_handle);
330
331 return 1;
332 }
333
334 /* output */
335 ntc_interface_debug_print("ntc: weighted moving average filter is %0.2f %0.2f %0.2f %0.2f %0.2f.\n",
336 weight[0], weight[1], weight[2], weight[3], weight[4]);
337 }
338 else if (filter == NTC_FILTER_LIMITING)
339 {
340 /* set filter limiting */
341 res = ntc_set_filter(&gs_handle, NTC_FILTER_LIMITING);
342 if (res != 0)
343 {
344 ntc_interface_debug_print("ntc: set filter failed.\n");
345 (void)ntc_deinit(&gs_handle);
346
347 return 1;
348 }
349
350 /* set filter limiting 10.0C */
351 res = ntc_set_filter_limiting(&gs_handle, 10.0f);
352 if (res != 0)
353 {
354 ntc_interface_debug_print("ntc: set filter limiting failed.\n");
355 (void)ntc_deinit(&gs_handle);
356
357 return 1;
358 }
359
360 /* output */
361 ntc_interface_debug_print("ntc: limiting filter is %0.2fC.\n", 10.0f);
362 }
363 else
364 {
365 /* set filter kalman */
366 res = ntc_set_filter(&gs_handle, NTC_FILTER_KALMAN);
367 if (res != 0)
368 {
369 ntc_interface_debug_print("ntc: set filter failed.\n");
370 (void)ntc_deinit(&gs_handle);
371
372 return 1;
373 }
374
375 /* set filter kalman */
376 res = ntc_set_filter_kalman(&gs_handle, 0.005f, 0.5f, 1.0f, nanf(""));
377 if (res != 0)
378 {
379 ntc_interface_debug_print("ntc: set filter kalman failed.\n");
380 (void)ntc_deinit(&gs_handle);
381
382 return 1;
383 }
384
385 /* output */
386 ntc_interface_debug_print("ntc: kalman q(process noise covariance) is %0.3f.\n", 0.005f);
387 ntc_interface_debug_print("ntc: kalman r(measurement noise covariance) is %0.2f.\n", 0.5f);
388 ntc_interface_debug_print("ntc: kalman p(estimation error covariance) is %0.2f.\n", 1.0f);
389 ntc_interface_debug_print("ntc: kalman x(estimated value) is read the current adc.\n");
390 }
391
392 for (i = 0; i < times; i++)
393 {
394 float ohm;
395 float degrees_celsius;
396
397 /* read temperature */
398 res = ntc_read_temperature(&gs_handle, &ohm, &degrees_celsius);
399 if (res != 0)
400 {
401 ntc_interface_debug_print("ntc: read temperature failed.\n");
402 (void)ntc_deinit(&gs_handle);
403
404 return 1;
405 }
406
407 /* output */
408 ntc_interface_debug_print("ntc: resistance is %0.2fohm.\n", ohm);
409 ntc_interface_debug_print("ntc: temperature is %0.2fC.\n", degrees_celsius);
410
411 /* delay 1000ms */
412 ntc_interface_delay_ms(1000);
413 }
414
415 /* finish read test */
416 ntc_interface_debug_print("ntc: finish read test.\n");
417 (void)ntc_deinit(&gs_handle);
418
419 return 0;
420}
421
436uint8_t ntc_read_steinhart_hart_test(ntc_circuit_t circuit, float r_fixed_ohm,
437 double a, double b, double c, ntc_filter_t filter, uint32_t times)
438{
439 uint8_t res;
440 uint32_t i;
441 ntc_info_t info;
442
443 /* link interface function */
444 DRIVER_NTC_LINK_INIT(&gs_handle, ntc_handle_t);
445 DRIVER_NTC_LINK_ADC_INIT(&gs_handle, ntc_interface_adc_init);
446 DRIVER_NTC_LINK_ADC_DEINIT(&gs_handle, ntc_interface_adc_deinit);
447 DRIVER_NTC_LINK_ADC_READ(&gs_handle, ntc_interface_adc_read);
448 DRIVER_NTC_LINK_DELAY_MS(&gs_handle, ntc_interface_delay_ms);
449 DRIVER_NTC_LINK_DEBUG_PRINT(&gs_handle, ntc_interface_debug_print);
450
451 /* get information */
452 res = ntc_info(&info);
453 if (res != 0)
454 {
455 ntc_interface_debug_print("ntc: get info failed.\n");
456
457 return 1;
458 }
459 else
460 {
461 /* print chip info */
462 ntc_interface_debug_print("ntc: chip is %s.\n", info.chip_name);
463 ntc_interface_debug_print("ntc: manufacturer is %s.\n", info.manufacturer_name);
464 ntc_interface_debug_print("ntc: interface is %s.\n", info.interface);
465 ntc_interface_debug_print("ntc: driver version is %d.%d.\n", info.driver_version / 1000, (info.driver_version % 1000) / 100);
466 ntc_interface_debug_print("ntc: min supply voltage is %0.1fV.\n", info.supply_voltage_min_v);
467 ntc_interface_debug_print("ntc: max supply voltage is %0.1fV.\n", info.supply_voltage_max_v);
468 ntc_interface_debug_print("ntc: max current is %0.2fmA.\n", info.max_current_ma);
469 ntc_interface_debug_print("ntc: max temperature is %0.1fC.\n", info.temperature_max);
470 ntc_interface_debug_print("ntc: min temperature is %0.1fC.\n", info.temperature_min);
471 }
472
473 /* init */
474 res = ntc_init(&gs_handle);
475 if (res != 0)
476 {
477 ntc_interface_debug_print("ntc: init failed.\n");
478
479 return 1;
480 }
481
482 /* start read test */
483 ntc_interface_debug_print("ntc: start read test.\n");
484
485 /* output */
486 if (circuit == NTC_CIRCUIT_VCC_NTC_R_GND)
487 {
488 ntc_interface_debug_print("ntc: circuit is vcc -> ntc -> r_fixed -> gnd.\n");
489 }
490 else
491 {
492 ntc_interface_debug_print("ntc: circuit is vcc -> r_fixed -> ntc -> gnd.\n");
493 }
494 ntc_interface_debug_print("ntc: circuit fixed resistor is %0.2f ohm.\n", r_fixed_ohm);
495 ntc_interface_debug_print("ntc: steinhart hart A is %e.\n", a);
496 ntc_interface_debug_print("ntc: steinhart hart B is %e.\n", b);
497 ntc_interface_debug_print("ntc: steinhart hart C is %e.\n", c);
498 if (filter == NTC_FILTER_NONE)
499 {
500 ntc_interface_debug_print("ntc: filter is none.\n");
501 }
502 else if (filter == NTC_FILTER_FIRST_ORDER_LAG)
503 {
504 ntc_interface_debug_print("ntc: filter is first order lag.\n");
505 }
506 else if (filter == NTC_FILTER_MEDIAN)
507 {
508 ntc_interface_debug_print("ntc: filter is median.\n");
509 }
510 else if (filter == NTC_FILTER_ANTI_SPIKE_AVERAGE)
511 {
512 ntc_interface_debug_print("ntc: filter is anti spike average.\n");
513 }
514 else if (filter == NTC_FILTER_MOVING_AVERAGE)
515 {
516 ntc_interface_debug_print("ntc: filter is moving average.\n");
517 }
518 else if (filter == NTC_FILTER_WEIGHTED_MOVING_AVERAGE)
519 {
520 ntc_interface_debug_print("ntc: filter is weighted moving average.\n");
521 }
522 else if (filter == NTC_FILTER_LIMITING)
523 {
524 ntc_interface_debug_print("ntc: filter is limiting.\n");
525 }
526 else
527 {
528 ntc_interface_debug_print("ntc: filter is kalman.\n");
529 }
530
531 /* set circuit */
532 res = ntc_set_circuit(&gs_handle, circuit);
533 if (res != 0)
534 {
535 ntc_interface_debug_print("ntc: set circuit failed.\n");
536 (void)ntc_deinit(&gs_handle);
537
538 return 1;
539 }
540
541 /* set circuit fixed resistor */
542 res = ntc_set_circuit_fixed_resistor(&gs_handle, r_fixed_ohm);
543 if (res != 0)
544 {
545 ntc_interface_debug_print("ntc: set circuit fixed resistor failed.\n");
546 (void)ntc_deinit(&gs_handle);
547
548 return 1;
549 }
550
551 /* set algorithm steinhart hart */
552 res = ntc_set_algorithm(&gs_handle, NTC_ALGORITHM_STEINHART_HART);
553 if (res != 0)
554 {
555 ntc_interface_debug_print("ntc: set algorithm failed.\n");
556 (void)ntc_deinit(&gs_handle);
557
558 return 1;
559 }
560
561 /* set algorithm steinhart hart */
562 res = ntc_set_algorithm_steinhart_hart(&gs_handle, a, b, c);
563 if (res != 0)
564 {
565 ntc_interface_debug_print("ntc: set algorithm steinhart hart failed.\n");
566 (void)ntc_deinit(&gs_handle);
567
568 return 1;
569 }
570
571 if (filter == NTC_FILTER_NONE)
572 {
573 /* set filter none */
574 res = ntc_set_filter(&gs_handle, NTC_FILTER_NONE);
575 if (res != 0)
576 {
577 ntc_interface_debug_print("ntc: set filter failed.\n");
578 (void)ntc_deinit(&gs_handle);
579
580 return 1;
581 }
582 }
583 else if (filter == NTC_FILTER_FIRST_ORDER_LAG)
584 {
585 /* set filter first order lag */
586 res = ntc_set_filter(&gs_handle, NTC_FILTER_FIRST_ORDER_LAG);
587 if (res != 0)
588 {
589 ntc_interface_debug_print("ntc: set filter failed.\n");
590 (void)ntc_deinit(&gs_handle);
591
592 return 1;
593 }
594
595 /* set filter first order lag 0.8 */
596 res = ntc_set_filter_first_order_lag(&gs_handle, 0.8f);
597 if (res != 0)
598 {
599 ntc_interface_debug_print("ntc: set filter first order lag failed.\n");
600 (void)ntc_deinit(&gs_handle);
601
602 return 1;
603 }
604
605 /* output */
606 ntc_interface_debug_print("ntc: first order lag filter alpha is %.02f.\n", 0.8f);
607 }
608 else if (filter == NTC_FILTER_MEDIAN)
609 {
610 /* set filter median */
611 res = ntc_set_filter(&gs_handle, NTC_FILTER_MEDIAN);
612 if (res != 0)
613 {
614 ntc_interface_debug_print("ntc: set filter failed.\n");
615 (void)ntc_deinit(&gs_handle);
616
617 return 1;
618 }
619
620 /* set filter median length 5 */
621 res = ntc_set_filter_median_length(&gs_handle, 5);
622 if (res != 0)
623 {
624 ntc_interface_debug_print("ntc: set filter median length failed.\n");
625 (void)ntc_deinit(&gs_handle);
626
627 return 1;
628 }
629
630 /* output */
631 ntc_interface_debug_print("ntc: median filter length is %d.\n", 5);
632 }
633 else if (filter == NTC_FILTER_ANTI_SPIKE_AVERAGE)
634 {
635 /* set filter anti spike average */
636 res = ntc_set_filter(&gs_handle, NTC_FILTER_ANTI_SPIKE_AVERAGE);
637 if (res != 0)
638 {
639 ntc_interface_debug_print("ntc: set filter failed.\n");
640 (void)ntc_deinit(&gs_handle);
641
642 return 1;
643 }
644
645 /* set filter anti spike average length 5 */
646 res = ntc_set_filter_anti_spike_average_length(&gs_handle, 5);
647 if (res != 0)
648 {
649 ntc_interface_debug_print("ntc: set filter anti spike average length failed.\n");
650 (void)ntc_deinit(&gs_handle);
651
652 return 1;
653 }
654
655 /* output */
656 ntc_interface_debug_print("ntc: anti spike average filter length is %d.\n", 5);
657 }
658 else if (filter == NTC_FILTER_MOVING_AVERAGE)
659 {
660 /* set filter moving average */
661 res = ntc_set_filter(&gs_handle, NTC_FILTER_MOVING_AVERAGE);
662 if (res != 0)
663 {
664 ntc_interface_debug_print("ntc: set filter failed.\n");
665 (void)ntc_deinit(&gs_handle);
666
667 return 1;
668 }
669
670 /* set filter moving average length 5 */
671 res = ntc_set_filter_moving_average_length(&gs_handle, 5);
672 if (res != 0)
673 {
674 ntc_interface_debug_print("ntc: set filter moving average length failed.\n");
675 (void)ntc_deinit(&gs_handle);
676
677 return 1;
678 }
679
680 /* output */
681 ntc_interface_debug_print("ntc: moving average filter length is %d.\n", 5);
682 }
683 else if (filter == NTC_FILTER_WEIGHTED_MOVING_AVERAGE)
684 {
685 float weight[] = {1.0, 2.0f, 3.0f, 4.0f, 5.0f};
686
687 /* set filter weighted moving average */
688 res = ntc_set_filter(&gs_handle, NTC_FILTER_WEIGHTED_MOVING_AVERAGE);
689 if (res != 0)
690 {
691 ntc_interface_debug_print("ntc: set filter failed.\n");
692 (void)ntc_deinit(&gs_handle);
693
694 return 1;
695 }
696
697 /* set filter weighted moving average length 5 */
698 res = ntc_set_filter_weighted_moving_average_length(&gs_handle, weight, 5);
699 if (res != 0)
700 {
701 ntc_interface_debug_print("ntc: set filter weighted moving average length failed.\n");
702 (void)ntc_deinit(&gs_handle);
703
704 return 1;
705 }
706
707 /* output */
708 ntc_interface_debug_print("ntc: weighted moving average filter is %0.2f %0.2f %0.2f %0.2f %0.2f.\n",
709 weight[0], weight[1], weight[2], weight[3], weight[4]);
710 }
711 else if (filter == NTC_FILTER_LIMITING)
712 {
713 /* set filter limiting */
714 res = ntc_set_filter(&gs_handle, NTC_FILTER_LIMITING);
715 if (res != 0)
716 {
717 ntc_interface_debug_print("ntc: set filter failed.\n");
718 (void)ntc_deinit(&gs_handle);
719
720 return 1;
721 }
722
723 /* set filter limiting 10.0C */
724 res = ntc_set_filter_limiting(&gs_handle, 10.0f);
725 if (res != 0)
726 {
727 ntc_interface_debug_print("ntc: set filter limiting failed.\n");
728 (void)ntc_deinit(&gs_handle);
729
730 return 1;
731 }
732
733 /* output */
734 ntc_interface_debug_print("ntc: limiting filter is %0.2fC.\n", 10.0f);
735 }
736 else
737 {
738 /* set filter kalman */
739 res = ntc_set_filter(&gs_handle, NTC_FILTER_KALMAN);
740 if (res != 0)
741 {
742 ntc_interface_debug_print("ntc: set filter failed.\n");
743 (void)ntc_deinit(&gs_handle);
744
745 return 1;
746 }
747
748 /* set filter kalman */
749 res = ntc_set_filter_kalman(&gs_handle, 0.005f, 0.5f, 1.0f, nanf(""));
750 if (res != 0)
751 {
752 ntc_interface_debug_print("ntc: set filter kalman failed.\n");
753 (void)ntc_deinit(&gs_handle);
754
755 return 1;
756 }
757
758 /* output */
759 ntc_interface_debug_print("ntc: kalman q(process noise covariance) is %0.3f.\n", 0.005f);
760 ntc_interface_debug_print("ntc: kalman r(measurement noise covariance) is %0.2f.\n", 0.5f);
761 ntc_interface_debug_print("ntc: kalman p(estimation error covariance) is %0.2f.\n", 1.0f);
762 ntc_interface_debug_print("ntc: kalman x(estimated value) is read the current adc.\n");
763 }
764
765 for (i = 0; i < times; i++)
766 {
767 float ohm;
768 float degrees_celsius;
769
770 /* read temperature */
771 res = ntc_read_temperature(&gs_handle, &ohm, &degrees_celsius);
772 if (res != 0)
773 {
774 ntc_interface_debug_print("ntc: read temperature failed.\n");
775 (void)ntc_deinit(&gs_handle);
776
777 return 1;
778 }
779
780 /* output */
781 ntc_interface_debug_print("ntc: resistance is %0.2fohm.\n", ohm);
782 ntc_interface_debug_print("ntc: temperature is %0.2fC.\n", degrees_celsius);
783
784 /* delay 1000ms */
785 ntc_interface_delay_ms(1000);
786 }
787
788 /* finish read test */
789 ntc_interface_debug_print("ntc: finish read test.\n");
790 (void)ntc_deinit(&gs_handle);
791
792 return 0;
793}
794
808uint8_t ntc_read_lookup_table_test(ntc_circuit_t circuit, float r_fixed_ohm,
809 const ntc_table_t *table, uint16_t table_len,
810 ntc_filter_t filter, uint32_t times)
811{
812 uint8_t res;
813 uint32_t i;
814 ntc_info_t info;
815
816 /* link interface function */
817 DRIVER_NTC_LINK_INIT(&gs_handle, ntc_handle_t);
818 DRIVER_NTC_LINK_ADC_INIT(&gs_handle, ntc_interface_adc_init);
819 DRIVER_NTC_LINK_ADC_DEINIT(&gs_handle, ntc_interface_adc_deinit);
820 DRIVER_NTC_LINK_ADC_READ(&gs_handle, ntc_interface_adc_read);
821 DRIVER_NTC_LINK_DELAY_MS(&gs_handle, ntc_interface_delay_ms);
822 DRIVER_NTC_LINK_DEBUG_PRINT(&gs_handle, ntc_interface_debug_print);
823
824 /* get information */
825 res = ntc_info(&info);
826 if (res != 0)
827 {
828 ntc_interface_debug_print("ntc: get info failed.\n");
829
830 return 1;
831 }
832 else
833 {
834 /* print chip info */
835 ntc_interface_debug_print("ntc: chip is %s.\n", info.chip_name);
836 ntc_interface_debug_print("ntc: manufacturer is %s.\n", info.manufacturer_name);
837 ntc_interface_debug_print("ntc: interface is %s.\n", info.interface);
838 ntc_interface_debug_print("ntc: driver version is %d.%d.\n", info.driver_version / 1000, (info.driver_version % 1000) / 100);
839 ntc_interface_debug_print("ntc: min supply voltage is %0.1fV.\n", info.supply_voltage_min_v);
840 ntc_interface_debug_print("ntc: max supply voltage is %0.1fV.\n", info.supply_voltage_max_v);
841 ntc_interface_debug_print("ntc: max current is %0.2fmA.\n", info.max_current_ma);
842 ntc_interface_debug_print("ntc: max temperature is %0.1fC.\n", info.temperature_max);
843 ntc_interface_debug_print("ntc: min temperature is %0.1fC.\n", info.temperature_min);
844 }
845
846 /* init */
847 res = ntc_init(&gs_handle);
848 if (res != 0)
849 {
850 ntc_interface_debug_print("ntc: init failed.\n");
851
852 return 1;
853 }
854
855 /* start read test */
856 ntc_interface_debug_print("ntc: start read test.\n");
857
858 /* output */
859 if (circuit == NTC_CIRCUIT_VCC_NTC_R_GND)
860 {
861 ntc_interface_debug_print("ntc: circuit is vcc -> ntc -> r_fixed -> gnd.\n");
862 }
863 else
864 {
865 ntc_interface_debug_print("ntc: circuit is vcc -> r_fixed -> ntc -> gnd.\n");
866 }
867 ntc_interface_debug_print("ntc: circuit fixed resistor is %0.2f ohm.\n", r_fixed_ohm);
868 ntc_interface_debug_print("ntc: table length is %d.\n", table_len);
869 if (filter == NTC_FILTER_NONE)
870 {
871 ntc_interface_debug_print("ntc: filter is none.\n");
872 }
873 else if (filter == NTC_FILTER_FIRST_ORDER_LAG)
874 {
875 ntc_interface_debug_print("ntc: filter is first order lag.\n");
876 }
877 else if (filter == NTC_FILTER_MEDIAN)
878 {
879 ntc_interface_debug_print("ntc: filter is median.\n");
880 }
881 else if (filter == NTC_FILTER_ANTI_SPIKE_AVERAGE)
882 {
883 ntc_interface_debug_print("ntc: filter is anti spike average.\n");
884 }
885 else if (filter == NTC_FILTER_MOVING_AVERAGE)
886 {
887 ntc_interface_debug_print("ntc: filter is moving average.\n");
888 }
889 else if (filter == NTC_FILTER_WEIGHTED_MOVING_AVERAGE)
890 {
891 ntc_interface_debug_print("ntc: filter is weighted moving average.\n");
892 }
893 else if (filter == NTC_FILTER_LIMITING)
894 {
895 ntc_interface_debug_print("ntc: filter is limiting.\n");
896 }
897 else
898 {
899 ntc_interface_debug_print("ntc: filter is kalman.\n");
900 }
901
902 /* set circuit */
903 res = ntc_set_circuit(&gs_handle, circuit);
904 if (res != 0)
905 {
906 ntc_interface_debug_print("ntc: set circuit failed.\n");
907 (void)ntc_deinit(&gs_handle);
908
909 return 1;
910 }
911
912 /* set circuit fixed resistor */
913 res = ntc_set_circuit_fixed_resistor(&gs_handle, r_fixed_ohm);
914 if (res != 0)
915 {
916 ntc_interface_debug_print("ntc: set circuit fixed resistor failed.\n");
917 (void)ntc_deinit(&gs_handle);
918
919 return 1;
920 }
921
922 /* set algorithm lookup table */
923 res = ntc_set_algorithm(&gs_handle, NTC_ALGORITHM_LOOKUP_TABLE);
924 if (res != 0)
925 {
926 ntc_interface_debug_print("ntc: set algorithm failed.\n");
927 (void)ntc_deinit(&gs_handle);
928
929 return 1;
930 }
931
932 /* load algorithm lookup table */
933 res = ntc_load_algorithm_lookup_table(&gs_handle, table, table_len);
934 if (res != 0)
935 {
936 ntc_interface_debug_print("ntc: set algorithm lookup table failed.\n");
937 (void)ntc_deinit(&gs_handle);
938
939 return 1;
940 }
941
942 if (filter == NTC_FILTER_NONE)
943 {
944 /* set filter none */
945 res = ntc_set_filter(&gs_handle, NTC_FILTER_NONE);
946 if (res != 0)
947 {
948 ntc_interface_debug_print("ntc: set filter failed.\n");
949 (void)ntc_deinit(&gs_handle);
950
951 return 1;
952 }
953 }
954 else if (filter == NTC_FILTER_FIRST_ORDER_LAG)
955 {
956 /* set filter first order lag */
957 res = ntc_set_filter(&gs_handle, NTC_FILTER_FIRST_ORDER_LAG);
958 if (res != 0)
959 {
960 ntc_interface_debug_print("ntc: set filter failed.\n");
961 (void)ntc_deinit(&gs_handle);
962
963 return 1;
964 }
965
966 /* set filter first order lag 0.8 */
967 res = ntc_set_filter_first_order_lag(&gs_handle, 0.8f);
968 if (res != 0)
969 {
970 ntc_interface_debug_print("ntc: set filter first order lag failed.\n");
971 (void)ntc_deinit(&gs_handle);
972
973 return 1;
974 }
975
976 /* output */
977 ntc_interface_debug_print("ntc: first order lag filter alpha is %.02f.\n", 0.8f);
978 }
979 else if (filter == NTC_FILTER_MEDIAN)
980 {
981 /* set filter median */
982 res = ntc_set_filter(&gs_handle, NTC_FILTER_MEDIAN);
983 if (res != 0)
984 {
985 ntc_interface_debug_print("ntc: set filter failed.\n");
986 (void)ntc_deinit(&gs_handle);
987
988 return 1;
989 }
990
991 /* set filter median length 5 */
992 res = ntc_set_filter_median_length(&gs_handle, 5);
993 if (res != 0)
994 {
995 ntc_interface_debug_print("ntc: set filter median length failed.\n");
996 (void)ntc_deinit(&gs_handle);
997
998 return 1;
999 }
1000
1001 /* output */
1002 ntc_interface_debug_print("ntc: median filter length is %d.\n", 5);
1003 }
1004 else if (filter == NTC_FILTER_ANTI_SPIKE_AVERAGE)
1005 {
1006 /* set filter anti spike average */
1007 res = ntc_set_filter(&gs_handle, NTC_FILTER_ANTI_SPIKE_AVERAGE);
1008 if (res != 0)
1009 {
1010 ntc_interface_debug_print("ntc: set filter failed.\n");
1011 (void)ntc_deinit(&gs_handle);
1012
1013 return 1;
1014 }
1015
1016 /* set filter anti spike average length 5 */
1017 res = ntc_set_filter_anti_spike_average_length(&gs_handle, 5);
1018 if (res != 0)
1019 {
1020 ntc_interface_debug_print("ntc: set filter anti spike average length failed.\n");
1021 (void)ntc_deinit(&gs_handle);
1022
1023 return 1;
1024 }
1025
1026 /* output */
1027 ntc_interface_debug_print("ntc: anti spike average filter length is %d.\n", 5);
1028 }
1029 else if (filter == NTC_FILTER_MOVING_AVERAGE)
1030 {
1031 /* set filter moving average */
1032 res = ntc_set_filter(&gs_handle, NTC_FILTER_MOVING_AVERAGE);
1033 if (res != 0)
1034 {
1035 ntc_interface_debug_print("ntc: set filter failed.\n");
1036 (void)ntc_deinit(&gs_handle);
1037
1038 return 1;
1039 }
1040
1041 /* set filter moving average length 5 */
1042 res = ntc_set_filter_moving_average_length(&gs_handle, 5);
1043 if (res != 0)
1044 {
1045 ntc_interface_debug_print("ntc: set filter moving average length failed.\n");
1046 (void)ntc_deinit(&gs_handle);
1047
1048 return 1;
1049 }
1050
1051 /* output */
1052 ntc_interface_debug_print("ntc: moving average filter length is %d.\n", 5);
1053 }
1054 else if (filter == NTC_FILTER_WEIGHTED_MOVING_AVERAGE)
1055 {
1056 float weight[] = {1.0, 2.0f, 3.0f, 4.0f, 5.0f};
1057
1058 /* set filter weighted moving average */
1059 res = ntc_set_filter(&gs_handle, NTC_FILTER_WEIGHTED_MOVING_AVERAGE);
1060 if (res != 0)
1061 {
1062 ntc_interface_debug_print("ntc: set filter failed.\n");
1063 (void)ntc_deinit(&gs_handle);
1064
1065 return 1;
1066 }
1067
1068 /* set filter weighted moving average length 5 */
1069 res = ntc_set_filter_weighted_moving_average_length(&gs_handle, weight, 5);
1070 if (res != 0)
1071 {
1072 ntc_interface_debug_print("ntc: set filter weighted moving average length failed.\n");
1073 (void)ntc_deinit(&gs_handle);
1074
1075 return 1;
1076 }
1077
1078 /* output */
1079 ntc_interface_debug_print("ntc: weighted moving average filter is %0.2f %0.2f %0.2f %0.2f %0.2f.\n",
1080 weight[0], weight[1], weight[2], weight[3], weight[4]);
1081 }
1082 else if (filter == NTC_FILTER_LIMITING)
1083 {
1084 /* set filter limiting */
1085 res = ntc_set_filter(&gs_handle, NTC_FILTER_LIMITING);
1086 if (res != 0)
1087 {
1088 ntc_interface_debug_print("ntc: set filter failed.\n");
1089 (void)ntc_deinit(&gs_handle);
1090
1091 return 1;
1092 }
1093
1094 /* set filter limiting 10.0C */
1095 res = ntc_set_filter_limiting(&gs_handle, 10.0f);
1096 if (res != 0)
1097 {
1098 ntc_interface_debug_print("ntc: set filter limiting failed.\n");
1099 (void)ntc_deinit(&gs_handle);
1100
1101 return 1;
1102 }
1103
1104 /* output */
1105 ntc_interface_debug_print("ntc: limiting filter is %0.2fC.\n", 10.0f);
1106 }
1107 else
1108 {
1109 /* set filter kalman */
1110 res = ntc_set_filter(&gs_handle, NTC_FILTER_KALMAN);
1111 if (res != 0)
1112 {
1113 ntc_interface_debug_print("ntc: set filter failed.\n");
1114 (void)ntc_deinit(&gs_handle);
1115
1116 return 1;
1117 }
1118
1119 /* set filter kalman */
1120 res = ntc_set_filter_kalman(&gs_handle, 0.005f, 0.5f, 1.0f, nanf(""));
1121 if (res != 0)
1122 {
1123 ntc_interface_debug_print("ntc: set filter kalman failed.\n");
1124 (void)ntc_deinit(&gs_handle);
1125
1126 return 1;
1127 }
1128
1129 /* output */
1130 ntc_interface_debug_print("ntc: kalman q(process noise covariance) is %0.3f.\n", 0.005f);
1131 ntc_interface_debug_print("ntc: kalman r(measurement noise covariance) is %0.2f.\n", 0.5f);
1132 ntc_interface_debug_print("ntc: kalman p(estimation error covariance) is %0.2f.\n", 1.0f);
1133 ntc_interface_debug_print("ntc: kalman x(estimated value) is read the current adc.\n");
1134 }
1135
1136 for (i = 0; i < times; i++)
1137 {
1138 float ohm;
1139 float degrees_celsius;
1140
1141 /* read temperature */
1142 res = ntc_read_temperature(&gs_handle, &ohm, &degrees_celsius);
1143 if (res != 0)
1144 {
1145 ntc_interface_debug_print("ntc: read temperature failed.\n");
1146 (void)ntc_deinit(&gs_handle);
1147
1148 return 1;
1149 }
1150
1151 /* output */
1152 ntc_interface_debug_print("ntc: resistance is %0.2fohm.\n", ohm);
1153 ntc_interface_debug_print("ntc: temperature is %0.2fC.\n", degrees_celsius);
1154
1155 /* delay 1000ms */
1156 ntc_interface_delay_ms(1000);
1157 }
1158
1159 /* finish read test */
1160 ntc_interface_debug_print("ntc: finish read test.\n");
1161 (void)ntc_deinit(&gs_handle);
1162
1163 return 0;
1164}
driver_ntc_read_test.h
driver ntc read test header file
ntc_read_temperature
uint8_t ntc_read_temperature(ntc_handle_t *handle, float *ohm, float *degrees_celsius)
read temperature
Definition driver_ntc.c:1410
ntc_set_algorithm_steinhart_hart
uint8_t ntc_set_algorithm_steinhart_hart(ntc_handle_t *handle, double a, double b, double c)
set algorithm steinhart hart
Definition driver_ntc.c:831
ntc_set_circuit
uint8_t ntc_set_circuit(ntc_handle_t *handle, ntc_circuit_t circuit)
set circuit
Definition driver_ntc.c:576
ntc_load_algorithm_lookup_table
uint8_t ntc_load_algorithm_lookup_table(ntc_handle_t *handle, const ntc_table_t *table, uint16_t table_len)
load algorithm lookup table
Definition driver_ntc.c:893
ntc_set_algorithm
uint8_t ntc_set_algorithm(ntc_handle_t *handle, ntc_algorithm_t algorithm)
set algorithm
Definition driver_ntc.c:673
ntc_filter_t
ntc_filter_t
ntc filter enumeration definition
Definition driver_ntc.h:90
ntc_info
uint8_t ntc_info(ntc_info_t *info)
get chip's information
Definition driver_ntc.c:1807
ntc_set_algorithm_beta_formula_r25_ohm
uint8_t ntc_set_algorithm_beta_formula_r25_ohm(ntc_handle_t *handle, float r25_ohm)
set algorithm beta formula r25 ohm
Definition driver_ntc.c:777
ntc_init
uint8_t ntc_init(ntc_handle_t *handle)
initialize the chip
Definition driver_ntc.c:1282
ntc_circuit_t
ntc_circuit_t
ntc circuit enumeration definition
Definition driver_ntc.h:71
ntc_info_t
struct ntc_info_s ntc_info_t
ntc information structure definition
ntc_set_algorithm_beta_formula_beta_value
uint8_t ntc_set_algorithm_beta_formula_beta_value(ntc_handle_t *handle, float beta)
set algorithm beta formula beta value
Definition driver_ntc.c:725
ntc_handle_t
struct ntc_handle_s ntc_handle_t
ntc handle structure definition
ntc_deinit
uint8_t ntc_deinit(ntc_handle_t *handle)
close the chip
Definition driver_ntc.c:1369
ntc_table_t
struct ntc_table_s ntc_table_t
ntc table structure definition
ntc_set_circuit_fixed_resistor
uint8_t ntc_set_circuit_fixed_resistor(ntc_handle_t *handle, float r_fixed_ohm)
set circuit fixed resistor
Definition driver_ntc.c:628
NTC_FILTER_MEDIAN
@ NTC_FILTER_MEDIAN
Definition driver_ntc.h:93
NTC_FILTER_ANTI_SPIKE_AVERAGE
@ NTC_FILTER_ANTI_SPIKE_AVERAGE
Definition driver_ntc.h:94
NTC_FILTER_FIRST_ORDER_LAG
@ NTC_FILTER_FIRST_ORDER_LAG
Definition driver_ntc.h:92
NTC_FILTER_NONE
@ NTC_FILTER_NONE
Definition driver_ntc.h:91
NTC_FILTER_MOVING_AVERAGE
@ NTC_FILTER_MOVING_AVERAGE
Definition driver_ntc.h:95
NTC_FILTER_KALMAN
@ NTC_FILTER_KALMAN
Definition driver_ntc.h:98
NTC_FILTER_WEIGHTED_MOVING_AVERAGE
@ NTC_FILTER_WEIGHTED_MOVING_AVERAGE
Definition driver_ntc.h:96
NTC_FILTER_LIMITING
@ NTC_FILTER_LIMITING
Definition driver_ntc.h:97
NTC_ALGORITHM_LOOKUP_TABLE
@ NTC_ALGORITHM_LOOKUP_TABLE
Definition driver_ntc.h:83
NTC_ALGORITHM_BETA_FORMULA
@ NTC_ALGORITHM_BETA_FORMULA
Definition driver_ntc.h:81
NTC_ALGORITHM_STEINHART_HART
@ NTC_ALGORITHM_STEINHART_HART
Definition driver_ntc.h:82
NTC_CIRCUIT_VCC_NTC_R_GND
@ NTC_CIRCUIT_VCC_NTC_R_GND
Definition driver_ntc.h:72
ntc_set_filter_first_order_lag
uint8_t ntc_set_filter_first_order_lag(ntc_handle_t *handle, float alpha)
set filter first order lag
Definition driver_ntc.c:995
ntc_set_filter_moving_average_length
uint8_t ntc_set_filter_moving_average_length(ntc_handle_t *handle, uint16_t length)
set filter moving average length
Definition driver_ntc.c:1105
ntc_set_filter_limiting
uint8_t ntc_set_filter_limiting(ntc_handle_t *handle, float degrees_celsius)
set filter limiting
Definition driver_ntc.c:1175
ntc_set_filter_median_length
uint8_t ntc_set_filter_median_length(ntc_handle_t *handle, uint16_t length)
set filter median length
Definition driver_ntc.c:1035
ntc_set_filter_anti_spike_average_length
uint8_t ntc_set_filter_anti_spike_average_length(ntc_handle_t *handle, uint16_t length)
set filter anti spike average length
Definition driver_ntc.c:1073
ntc_set_filter
uint8_t ntc_set_filter(ntc_handle_t *handle, ntc_filter_t filter)
set filter
Definition driver_ntc.c:950
ntc_set_filter_kalman
uint8_t ntc_set_filter_kalman(ntc_handle_t *handle, float q_process_noise_covariance, float r_measurement_noise_covariance, float p_estimation_error_covariance, float x_estimated_value)
set filter kalman
Definition driver_ntc.c:1202
ntc_set_filter_weighted_moving_average_length
uint8_t ntc_set_filter_weighted_moving_average_length(ntc_handle_t *handle, float *weight, uint16_t length)
set filter weighted moving average length
Definition driver_ntc.c:1137
ntc_interface_adc_init
uint8_t ntc_interface_adc_init(uint32_t *vcc_counter)
interface adc init
Definition driver_ntc_interface_template.c:47
ntc_interface_adc_deinit
uint8_t ntc_interface_adc_deinit(void)
interface adc deinit
Definition driver_ntc_interface_template.c:59
ntc_interface_adc_read
uint8_t ntc_interface_adc_read(uint32_t *counter, uint16_t len)
interface adc read
Definition driver_ntc_interface_template.c:73
ntc_interface_debug_print
void ntc_interface_debug_print(const char *const fmt,...)
interface print format data
Definition driver_ntc_interface_template.c:93
ntc_interface_delay_ms
void ntc_interface_delay_ms(uint32_t ms)
interface delay ms
Definition driver_ntc_interface_template.c:83
DRIVER_NTC_LINK_ADC_DEINIT
#define DRIVER_NTC_LINK_ADC_DEINIT(HANDLE, FUC)
link adc_deinit function
Definition driver_ntc.h:190
DRIVER_NTC_LINK_ADC_INIT
#define DRIVER_NTC_LINK_ADC_INIT(HANDLE, FUC)
link adc_init function
Definition driver_ntc.h:182
DRIVER_NTC_LINK_DELAY_MS
#define DRIVER_NTC_LINK_DELAY_MS(HANDLE, FUC)
link delay_ms function
Definition driver_ntc.h:206
DRIVER_NTC_LINK_INIT
#define DRIVER_NTC_LINK_INIT(HANDLE, STRUCTURE)
initialize ntc_handle_t structure
Definition driver_ntc.h:174
DRIVER_NTC_LINK_ADC_READ
#define DRIVER_NTC_LINK_ADC_READ(HANDLE, FUC)
link adc_read function
Definition driver_ntc.h:198
DRIVER_NTC_LINK_DEBUG_PRINT
#define DRIVER_NTC_LINK_DEBUG_PRINT(HANDLE, FUC)
link debug_print function
Definition driver_ntc.h:214
ntc_read_lookup_table_test
uint8_t ntc_read_lookup_table_test(ntc_circuit_t circuit, float r_fixed_ohm, const ntc_table_t *table, uint16_t table_len, ntc_filter_t filter, uint32_t times)
read lookup table test
Definition driver_ntc_read_test.c:808
ntc_read_beta_formula_test
uint8_t ntc_read_beta_formula_test(ntc_circuit_t circuit, float r_fixed_ohm, float beta, float r25_ohm, ntc_filter_t filter, uint32_t times)
read beta formula test
Definition driver_ntc_read_test.c:54
ntc_read_steinhart_hart_test
uint8_t ntc_read_steinhart_hart_test(ntc_circuit_t circuit, float r_fixed_ohm, double a, double b, double c, ntc_filter_t filter, uint32_t times)
read steinhart hart test
Definition driver_ntc_read_test.c:436
ntc_info_s::temperature_max
float temperature_max
Definition driver_ntc.h:153
ntc_info_s::supply_voltage_max_v
float supply_voltage_max_v
Definition driver_ntc.h:150
ntc_info_s::driver_version
uint32_t driver_version
Definition driver_ntc.h:154
ntc_info_s::temperature_min
float temperature_min
Definition driver_ntc.h:152
ntc_info_s::max_current_ma
float max_current_ma
Definition driver_ntc.h:151
ntc_info_s::manufacturer_name
char manufacturer_name[32]
Definition driver_ntc.h:147
ntc_info_s::supply_voltage_min_v
float supply_voltage_min_v
Definition driver_ntc.h:149
ntc_info_s::interface
char interface[8]
Definition driver_ntc.h:148
ntc_info_s::chip_name
char chip_name[32]
Definition driver_ntc.h:146