LibDriver AS608  1.0.0
AS608 full-featured driver
driver_as608.c
Go to the documentation of this file.
1 
37 #include "driver_as608.h"
38 #include <math.h>
39 
43 #define CHIP_NAME "Synochip AS608"
44 #define MANUFACTURER_NAME "Synochip"
45 #define SUPPLY_VOLTAGE_MIN 3.0f
46 #define SUPPLY_VOLTAGE_MAX 3.6f
47 #define MAX_CURRENT 60.0f
48 #define TEMPERATURE_MIN -40.0f
49 #define TEMPERATURE_MAX 85.0f
50 #define DRIVER_VERSION 1000
55 #define AS608_COMMAND_GET_IMAGE 0x01
56 #define AS608_COMMAND_GEN_CHAR 0x02
57 #define AS608_COMMAND_MATCH 0x03
58 #define AS608_COMMAND_SEARCH 0x04
59 #define AS608_COMMAND_REG_MODEL 0x05
60 #define AS608_COMMAND_STORE_CHAR 0x06
61 #define AS608_COMMAND_LOAD_CHAR 0x07
62 #define AS608_COMMAND_UP_CHAR 0x08
63 #define AS608_COMMAND_DOWN_CHAR 0x09
64 #define AS608_COMMAND_UP_IMAGE 0x0A
65 #define AS608_COMMAND_DOWN_IMAGE 0x0B
66 #define AS608_COMMAND_DELETE_CHAR 0x0C
67 #define AS608_COMMAND_EMPTY 0x0D
68 #define AS608_COMMAND_WRITE_REG 0x0E
69 #define AS608_COMMAND_READ_SYS_PARA 0x0F
70 #define AS608_COMMAND_ENROLL 0x10
71 #define AS608_COMMAND_IDENTIFY 0x11
72 #define AS608_COMMAND_SET_PWD 0x12
73 #define AS608_COMMAND_VFY_PWD 0x13
74 #define AS608_COMMAND_GET_RANDOM_CODE 0x14
75 #define AS608_COMMAND_SET_CHIP_ADDR 0x15
76 #define AS608_COMMAND_READ_INFO_PAGE 0x16
77 #define AS608_COMMAND_PORT_CONTROL 0x17
78 #define AS608_COMMAND_WRITE_NOTEPAD 0x18
79 #define AS608_COMMAND_READ_NOTEPAD 0x19
80 #define AS608_COMMAND_BURN_CODE 0x1A
81 #define AS608_COMMAND_HIGH_SPEED_SEARCH 0x1B
82 #define AS608_COMMAND_GEN_BIN_IMAGE 0x1C
83 #define AS608_COMMAND_VALID_TEMPLATE_NUM 0x1D
84 #define AS608_COMMAND_USER_GPIO 0x1E
85 #define AS608_COMMAND_READ_INDEX_TABLE 0x1F
90 #define AS608_TYPE_COMMAND 0x01
91 #define AS608_TYPE_DATA 0x02
92 #define AS608_TYPE_RESPONSE 0x07
93 #define AS608_TYPE_END 0x08
108 static uint8_t a_as608_uart_write(as608_handle_t *handle, uint32_t addr, uint8_t type,
109  uint8_t *buf, uint16_t len)
110 {
111  uint16_t i;
112  uint16_t sum;
113  uint16_t l;
114 
115  if ((len + 11) > 384) /* check length */
116  {
117  return 2; /* return error */
118  }
119  handle->buf[0] = 0xEF; /* header 0 */
120  handle->buf[1] = 0x01; /* header 1 */
121  handle->buf[2] = (addr >> 24) & 0xFF; /* set addr 3 */
122  handle->buf[3] = (addr >> 16) & 0xFF; /* set addr 2 */
123  handle->buf[4] = (addr >> 8) & 0xFF; /* set addr 1 */
124  handle->buf[5] = (addr >> 0) & 0xFF; /* set addr 0 */
125  handle->buf[6] = type; /* set type */
126  l = len + 2; /* add check crc */
127  handle->buf[7] = (l >> 8) & 0xFF; /* set l msb */
128  handle->buf[8] = (l >> 0) & 0xFF; /* set l lsb */
129  memcpy(handle->buf + 9, buf, len); /* copy data */
130  l = len + 9; /* add 9 */
131  sum = 0; /* init 0 */
132  for(i = 6; i < l; i++) /* loop */
133  {
134  sum += handle->buf[i]; /* sum all */
135  }
136  handle->buf[l] = (sum >> 8) & 0xFF; /* set sum msb */
137  handle->buf[l + 1] = (sum >> 0) & 0xFF; /* set sum lsb */
138 
139  if (handle->uart_flush() != 0) /* uart flush */
140  {
141  return 1; /* return error */
142  }
143  if (handle->uart_write(handle->buf, l + 2) != 0) /* write data */
144  {
145  return 1; /* return error */
146  }
147 
148  return 0; /* success return 0 */
149 }
150 
168 static uint8_t a_as608_uart_decode(as608_handle_t *handle, uint32_t ms, uint32_t *addr,
169  uint8_t *buf, uint16_t *len)
170 {
171  uint16_t i;
172  uint16_t l;
173  uint16_t ll;
174  uint16_t sum;
175  uint16_t sum_check;
176  uint16_t read_len;
177 
178  handle->delay_ms(ms); /* delay */
179  l = handle->uart_read(handle->buf, 384); /* read data */
180  if (l != 0) /* check length */
181  {
182  if (l < 12) /* check min length */
183  {
184  handle->debug_print("as608: decode failed.\n"); /* decode failed */
185 
186  return 2; /* return error */
187  }
188  ll = l - 2; /* no check sum */
189  sum = 0; /* init 0 */
190  for(i = 6; i < ll; i++) /* loop */
191  {
192  sum += handle->buf[i]; /* sum all */
193  }
194  sum_check = (uint16_t)((uint16_t)handle->buf[l - 2] << 8) | handle->buf[l - 1]; /* sum check */
195  if (sum != sum_check) /* check sum */
196  {
197  handle->debug_print("as608: sum check error.\n"); /* sum check error */
198 
199  return 3; /* return error */
200  }
201  ll = (uint16_t)((uint16_t)handle->buf[7] << 8) | handle->buf[8]; /* get length */
202  if (ll + 9 != l) /* check length */
203  {
204  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
205 
206  return 4; /* return error */
207  }
208  if ((handle->buf[0] != 0xEF) && (handle->buf[1] != 0x01)) /* check header */
209  {
210  handle->debug_print("as608: header is invalid.\n"); /* header is invalid */
211 
212  return 5; /* return error */
213  }
214  *addr = (uint32_t)((uint32_t)handle->buf[2] << 24) |
215  (uint32_t)((uint32_t)handle->buf[3] << 16) |
216  (uint32_t)((uint32_t)handle->buf[4] << 8) |
217  (uint32_t)((uint32_t)handle->buf[5] << 0); /* set address */
218  if (handle->buf[6] != AS608_TYPE_RESPONSE) /* check type */
219  {
220  handle->debug_print("as608: type is invalid.\n"); /* type is invalid */
221 
222  return 6; /* return error */
223  }
224  read_len = ((*len) < (ll - 2)) ? (*len) : (ll - 2); /* set length */
225  memcpy(buf, &handle->buf[9], read_len); /* copy data */
226  *len = read_len; /* set addr */
227 
228  return 0; /* success return 0 */
229  }
230  else
231  {
232  handle->debug_print("as608: no response.\n"); /* no response */
233 
234  return 2; /* return error */
235  }
236 }
237 
256 static uint8_t a_as608_uart_decode_with_length(as608_handle_t *handle, uint16_t input_len,
257  uint32_t ms, uint32_t *addr,
258  uint8_t *buf, uint16_t *len)
259 {
260  uint16_t i;
261  uint16_t l;
262  uint16_t ll;
263  uint16_t sum;
264  uint16_t sum_check;
265  uint16_t read_len;
266 
267  handle->delay_ms(ms); /* delay */
268  l = handle->uart_read(handle->buf, input_len); /* read data */
269  if (l != 0) /* check length */
270  {
271  if (l < 12) /* check min length */
272  {
273  handle->debug_print("as608: decode failed.\n"); /* decode failed */
274 
275  return 2; /* return error */
276  }
277  if (l != input_len) /* check min length */
278  {
279  handle->debug_print("as608: decode failed.\n"); /* decode failed */
280 
281  return 2; /* return error */
282  }
283  ll = l - 2; /* no check sum */
284  sum = 0; /* init 0 */
285  for(i = 6; i < ll; i++) /* loop */
286  {
287  sum += handle->buf[i]; /* sum all */
288  }
289  sum_check = (uint16_t)((uint16_t)handle->buf[l - 2] << 8) | handle->buf[l - 1]; /* sum check */
290  if (sum != sum_check) /* check sum */
291  {
292  handle->debug_print("as608: sum check error.\n"); /* sum check error */
293 
294  return 3; /* return error */
295  }
296  ll = (uint16_t)((uint16_t)handle->buf[7] << 8) | handle->buf[8]; /* get length */
297  if (ll + 9 != l) /* check length */
298  {
299  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
300 
301  return 4; /* return error */
302  }
303  if ((handle->buf[0] != 0xEF) && (handle->buf[1] != 0x01)) /* check header */
304  {
305  handle->debug_print("as608: header is invalid.\n"); /* header is invalid */
306 
307  return 5; /* return error */
308  }
309  *addr = (uint32_t)((uint32_t)handle->buf[2] << 24) |
310  (uint32_t)((uint32_t)handle->buf[3] << 16) |
311  (uint32_t)((uint32_t)handle->buf[4] << 8) |
312  (uint32_t)((uint32_t)handle->buf[5] << 0); /* set address */
313  if (handle->buf[6] != AS608_TYPE_RESPONSE) /* check type */
314  {
315  handle->debug_print("as608: type is invalid.\n"); /* type is invalid */
316 
317  return 6; /* return error */
318  }
319  read_len = ((*len) < (ll - 2)) ? (*len) : (ll - 2); /* set length */
320  memcpy(buf, &handle->buf[9], read_len); /* copy data */
321  *len = read_len; /* set addr */
322 
323  return 0; /* success return 0 */
324  }
325  else
326  {
327  handle->debug_print("as608: no response.\n"); /* no response */
328 
329  return 2; /* return error */
330  }
331 }
332 
352 static uint8_t a_as608_uart_parse_data(as608_handle_t *handle, uint32_t ms,uint32_t *addr, uint8_t *buf,
353  uint16_t *len, as608_bool_t *end_enable, as608_bool_t *full_enable)
354 {
355  uint16_t i;
356  uint16_t l;
357  uint16_t ll;
358  uint16_t sum;
359  uint16_t sum_check;
360  uint16_t read_len;
361 
362  handle->delay_ms(ms); /* delay */
363  l = handle->uart_read(handle->buf, 9); /* read data */
364  if (l != 0) /* check length */
365  {
366  if (l != 9) /* check min length */
367  {
368  handle->debug_print("as608: parse failed.\n"); /* parse failed */
369 
370  return 2; /* return error */
371  }
372  l = (uint16_t)(((uint16_t)handle->buf[7]) << 8) | handle->buf[8]; /* get length */
373  if (l > 256)
374  {
375  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
376 
377  return 4; /* return error */
378  }
379  ll = handle->uart_read(&handle->buf[9], l); /* read data */
380  if (ll != l) /* check the read length */
381  {
382  handle->debug_print("as608: parse failed.\n"); /* parse failed */
383 
384  return 2; /* return error */
385  }
386  l += 9; /* add header length */
387  ll = l - 2; /* no check sum */
388  sum = 0; /* init 0 */
389  for(i = 6; i < ll; i++) /* loop */
390  {
391  sum += handle->buf[i]; /* sum all */
392  }
393  sum_check = (uint16_t)((uint16_t)handle->buf[l - 2] << 8) | handle->buf[l - 1]; /* sum check */
394  if (sum != sum_check) /* check sum */
395  {
396  handle->debug_print("as608: sum check error.\n"); /* sum check error */
397 
398  return 3; /* return error */
399  }
400  ll = (uint16_t)((uint16_t)handle->buf[7] << 8) | handle->buf[8]; /* get length */
401  if (ll + 9 != l) /* check length */
402  {
403  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
404 
405  return 4; /* return error */
406  }
407  if ((handle->buf[0] != 0xEF) && (handle->buf[1] != 0x01)) /* check header */
408  {
409  handle->debug_print("as608: header is invalid.\n"); /* header is invalid */
410 
411  return 5; /* return error */
412  }
413  *addr = (uint32_t)((uint32_t)handle->buf[2] << 24) |
414  (uint32_t)((uint32_t)handle->buf[3] << 16) |
415  (uint32_t)((uint32_t)handle->buf[4] << 8) |
416  (uint32_t)((uint32_t)handle->buf[5] << 0); /* set address */
417  if (handle->buf[6] == AS608_TYPE_DATA) /* if data type */
418  {
419  *end_enable = AS608_BOOL_FALSE; /* disable end */
420  }
421  else if (handle->buf[6] == AS608_TYPE_END) /* if end */
422  {
423  *end_enable = AS608_BOOL_TRUE; /* enable end */
424  }
425  else
426  {
427  handle->debug_print("as608: type is invalid.\n"); /* type is invalid */
428 
429  return 6; /* return error */
430  }
431  read_len = ((*len) < (ll - 2)) ? (*len) : (ll - 2); /* set length */
432  memcpy(buf, &handle->buf[9], read_len); /* copy data */
433  *len = read_len; /* set addr */
434  if ((ll - 2) > (*len)) /* check buffer full */
435  {
436  *full_enable = AS608_BOOL_TRUE; /* full */
437  }
438  else
439  {
440  *full_enable = AS608_BOOL_FALSE; /* not full */
441  }
442 
443  return 0; /* success return 0 */
444  }
445  else
446  {
447  handle->debug_print("as608: no response.\n"); /* no response */
448 
449  return 2; /* return error */
450  }
451 }
452 
465 uint8_t as608_init(as608_handle_t *handle, uint32_t addr)
466 {
467  uint8_t res;
468  uint8_t buf[17];
469  uint16_t len;
470  uint32_t addr_check;
471 
472  if (handle == NULL) /* check handle */
473  {
474  return 2; /* return error */
475  }
476  if (handle->debug_print == NULL) /* check debug_print */
477  {
478  return 3; /* return error */
479  }
480  if (handle->uart_init == NULL) /* check uart_init */
481  {
482  handle->debug_print("as608: uart_init is null.\n"); /* uart_init is null */
483 
484  return 3; /* return error */
485  }
486  if (handle->uart_deinit == NULL) /* check uart_deinit */
487  {
488  handle->debug_print("as608: uart_deinit is null.\n"); /* uart_deinit is null */
489 
490  return 3; /* return error */
491  }
492  if (handle->uart_read == NULL) /* check uart_read */
493  {
494  handle->debug_print("as608: uart_read is null.\n"); /* uart_read is null */
495 
496  return 3; /* return error */
497  }
498  if (handle->uart_write == NULL) /* check uart_write */
499  {
500  handle->debug_print("as608: uart_write is null.\n"); /* uart_write is null */
501 
502  return 3; /* return error */
503  }
504  if (handle->uart_flush == NULL) /* check uart_flush */
505  {
506  handle->debug_print("as608: uart_flush is null.\n"); /* uart_flush is null */
507 
508  return 3; /* return error */
509  }
510  if (handle->delay_ms == NULL) /* check delay_ms */
511  {
512  handle->debug_print("as608: delay_ms is null.\n"); /* delay_ms is null */
513 
514  return 3; /* return error */
515  }
516 
517  if (handle->uart_init() != 0) /* uart init */
518  {
519  handle->debug_print("as608: uart init failed.\n"); /* uart init failed */
520 
521  return 1; /* return error */
522  }
523  handle->delay_ms(100); /* delay 100ms */
524 
525  buf[0] = AS608_COMMAND_READ_SYS_PARA; /* read sys para */
526  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 1); /* write data */
527  if (res != 0) /* check result */
528  {
529  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
530  (void)handle->uart_deinit(); /* uart deinit */
531 
532  return 4; /* return error */
533  }
534  len = 17; /* len 17 */
535  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
536  if (res != 0) /* check result */
537  {
538  (void)handle->uart_deinit(); /* uart deinit */
539 
540  return 4; /* return error */
541  }
542  if (addr_check != addr) /* check addr */
543  {
544  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
545  (void)handle->uart_deinit(); /* uart deinit */
546 
547  return 4; /* return error */
548  }
549  if (len != 17) /* check length */
550  {
551  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
552  (void)handle->uart_deinit(); /* uart deinit */
553 
554  return 4; /* return error */
555  }
556  handle->status = buf[0]; /* save status */
557  handle->packet_size = (uint16_t)(32.0f * powf(2.0f, (float)((uint16_t)
558  ((uint16_t)buf[13] << 8) | buf[14]))); /* packet size */
559 
560  handle->inited = 1; /* flag finish initialization */
561 
562  return 0; /* success return 0 */
563 }
564 
575 uint8_t as608_deinit(as608_handle_t *handle)
576 {
577  if (handle == NULL) /* check handle */
578  {
579  return 2; /* return error */
580  }
581  if (handle->inited != 1) /* check handle initialization */
582  {
583  return 3; /* return error */
584  }
585 
586  if (handle->uart_deinit() != 0) /* uart deinit */
587  {
588  handle->debug_print("as608: uart deinit failed.\n"); /* uart deinit failed */
589 
590  return 1; /* return error */
591  }
592  handle->inited = 0; /* flag close */
593 
594  return 0; /* success return 0 */
595 }
596 
607 uint8_t as608_get_last_status(as608_handle_t *handle, as608_status_t *status)
608 {
609  if (handle == NULL) /* check handle */
610  {
611  return 2; /* return error */
612  }
613  if (handle->inited != 1) /* check handle initialization */
614  {
615  return 3; /* return error */
616  }
617 
618  *status = (as608_status_t)handle->status; /* get status */
619 
620  return 0; /* success return 0 */
621 }
622 
638 uint8_t as608_get_image(as608_handle_t *handle, uint32_t addr, as608_status_t *status)
639 {
640  uint8_t res;
641  uint8_t buf[1];
642  uint16_t len;
643  uint32_t addr_check;
644 
645  if (handle == NULL) /* check handle */
646  {
647  return 2; /* return error */
648  }
649  if (handle->inited != 1) /* check handle initialization */
650  {
651  return 3; /* return error */
652  }
653 
654  buf[0] = AS608_COMMAND_GET_IMAGE; /* get image */
655  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 1); /* write data */
656  if (res != 0) /* check result */
657  {
658  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
659 
660  return 1; /* return error */
661  }
662  len = 1; /* len 1 */
663  res = a_as608_uart_decode(handle, 500, &addr_check, buf, &len); /* decode */
664  if (res != 0) /* check result */
665  {
666  return 4; /* return error */
667  }
668  if (addr_check != addr) /* check addr */
669  {
670  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
671 
672  return 5; /* return error */
673  }
674  if (len != 1) /* check length */
675  {
676  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
677 
678  return 6; /* return error */
679  }
680  handle->status = buf[0]; /* save status */
681  *status = (as608_status_t)handle->status; /* set status */
682 
683  return 0; /* success return 0 */
684 }
685 
702 uint8_t as608_generate_feature(as608_handle_t *handle, uint32_t addr, as608_buffer_number_t num, as608_status_t *status)
703 {
704  uint8_t res;
705  uint8_t buf[2];
706  uint16_t len;
707  uint32_t addr_check;
708 
709  if (handle == NULL) /* check handle */
710  {
711  return 2; /* return error */
712  }
713  if (handle->inited != 1) /* check handle initialization */
714  {
715  return 3; /* return error */
716  }
717 
718  buf[0] = AS608_COMMAND_GEN_CHAR; /* generate char */
719  buf[1] = num; /* set buffer number */
720  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 2); /* write data */
721  if (res != 0) /* check result */
722  {
723  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
724 
725  return 1; /* return error */
726  }
727  len = 1; /* len 1 */
728  res = a_as608_uart_decode(handle, 400, &addr_check, buf, &len); /* decode */
729  if (res != 0) /* check result */
730  {
731  return 4; /* return error */
732  }
733  if (addr_check != addr) /* check addr */
734  {
735  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
736 
737  return 5; /* return error */
738  }
739  if (len != 1) /* check length */
740  {
741  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
742 
743  return 6; /* return error */
744  }
745  handle->status = buf[0]; /* save status */
746  *status = (as608_status_t)handle->status; /* set status */
747 
748  return 0; /* success return 0 */
749 }
750 
767 uint8_t as608_match_feature(as608_handle_t *handle, uint32_t addr, uint16_t *score, as608_status_t *status)
768 {
769  uint8_t res;
770  uint8_t buf[3];
771  uint16_t len;
772  uint32_t addr_check;
773 
774  if (handle == NULL) /* check handle */
775  {
776  return 2; /* return error */
777  }
778  if (handle->inited != 1) /* check handle initialization */
779  {
780  return 3; /* return error */
781  }
782 
783  buf[0] = AS608_COMMAND_MATCH; /* match feature */
784  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 1); /* write data */
785  if (res != 0) /* check result */
786  {
787  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
788 
789  return 1; /* return error */
790  }
791  len = 3; /* len 3 */
792  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
793  if (res != 0) /* check result */
794  {
795  return 4; /* return error */
796  }
797  if (addr_check != addr) /* check addr */
798  {
799  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
800 
801  return 5; /* return error */
802  }
803  if (len != 3) /* check length */
804  {
805  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
806 
807  return 6; /* return error */
808  }
809  handle->status = buf[0]; /* save status */
810  *status = (as608_status_t)handle->status; /* set status */
811  *score = (uint16_t)((uint16_t)buf[1] << 8) | buf[2]; /* set the score */
812 
813  return 0; /* success return 0 */
814 }
815 
836 uint8_t as608_search_feature(as608_handle_t *handle, uint32_t addr, as608_buffer_number_t num,
837  uint16_t start_page, uint16_t page_number, uint16_t *found_page,
838  uint16_t *score, as608_status_t *status)
839 {
840  uint8_t res;
841  uint8_t buf[6];
842  uint16_t len;
843  uint32_t addr_check;
844 
845  if (handle == NULL) /* check handle */
846  {
847  return 2; /* return error */
848  }
849  if (handle->inited != 1) /* check handle initialization */
850  {
851  return 3; /* return error */
852  }
853 
854  buf[0] = AS608_COMMAND_SEARCH; /* search char */
855  buf[1] = num; /* set buffer number */
856  buf[2] = (start_page >> 8) & 0xFF; /* start page msb */
857  buf[3] = (start_page >> 0) & 0xFF; /* start page lsb */
858  buf[4] = (page_number >> 8) & 0xFF; /* page number msb */
859  buf[5] = (page_number >> 0) & 0xFF; /* page number lsb */
860  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 6); /* write data */
861  if (res != 0) /* check result */
862  {
863  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
864 
865  return 1; /* return error */
866  }
867  len = 5; /* len 5 */
868  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
869  if (res != 0) /* check result */
870  {
871  return 4; /* return error */
872  }
873  if (addr_check != addr) /* check addr */
874  {
875  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
876 
877  return 5; /* return error */
878  }
879  if (len != 5) /* check length */
880  {
881  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
882 
883  return 6; /* return error */
884  }
885  handle->status = buf[0]; /* save status */
886  *status = (as608_status_t)handle->status; /* set status */
887  *found_page = (uint16_t)((uint16_t)buf[1] << 8) | buf[2]; /* set the found page */
888  *score = (uint16_t)((uint16_t)buf[3] << 8) | buf[4]; /* set the score */
889 
890  return 0; /* success return 0 */
891 }
892 
908 uint8_t as608_combine_feature(as608_handle_t *handle, uint32_t addr, as608_status_t *status)
909 {
910  uint8_t res;
911  uint8_t buf[1];
912  uint16_t len;
913  uint32_t addr_check;
914 
915  if (handle == NULL) /* check handle */
916  {
917  return 2; /* return error */
918  }
919  if (handle->inited != 1) /* check handle initialization */
920  {
921  return 3; /* return error */
922  }
923 
924  buf[0] = AS608_COMMAND_REG_MODEL; /* reg model */
925  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 1); /* write data */
926  if (res != 0) /* check result */
927  {
928  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
929 
930  return 1; /* return error */
931  }
932  len = 1; /* len 1 */
933  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
934  if (res != 0) /* check result */
935  {
936  return 4; /* return error */
937  }
938  if (addr_check != addr) /* check addr */
939  {
940  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
941 
942  return 5; /* return error */
943  }
944  if (len != 1) /* check length */
945  {
946  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
947 
948  return 6; /* return error */
949  }
950  handle->status = buf[0]; /* save status */
951  *status = (as608_status_t)handle->status; /* set status */
952 
953  return 0; /* success return 0 */
954 }
955 
973 uint8_t as608_store_feature(as608_handle_t *handle, uint32_t addr, as608_buffer_number_t num,
974  uint16_t page_number, as608_status_t *status)
975 {
976  uint8_t res;
977  uint8_t buf[4];
978  uint16_t len;
979  uint32_t addr_check;
980 
981  if (handle == NULL) /* check handle */
982  {
983  return 2; /* return error */
984  }
985  if (handle->inited != 1) /* check handle initialization */
986  {
987  return 3; /* return error */
988  }
989 
990  buf[0] = AS608_COMMAND_STORE_CHAR; /* store char */
991  buf[1] = num; /* set buffer number */
992  buf[2] = (page_number >> 8) & 0xFF; /* page number msb */
993  buf[3] = (page_number >> 0) & 0xFF; /* page number lsb */
994  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 4); /* write data */
995  if (res != 0) /* check result */
996  {
997  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
998 
999  return 1; /* return error */
1000  }
1001  len = 1; /* len 1 */
1002  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
1003  if (res != 0) /* check result */
1004  {
1005  return 4; /* return error */
1006  }
1007  if (addr_check != addr) /* check addr */
1008  {
1009  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
1010 
1011  return 5; /* return error */
1012  }
1013  if (len != 1) /* check length */
1014  {
1015  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
1016 
1017  return 6; /* return error */
1018  }
1019  handle->status = buf[0]; /* save status */
1020  *status = (as608_status_t)handle->status; /* set status */
1021 
1022  return 0; /* success return 0 */
1023 }
1024 
1042 uint8_t as608_load_feature(as608_handle_t *handle, uint32_t addr, as608_buffer_number_t num,
1043  uint16_t page_number, as608_status_t *status)
1044 {
1045  uint8_t res;
1046  uint8_t buf[4];
1047  uint16_t len;
1048  uint32_t addr_check;
1049 
1050  if (handle == NULL) /* check handle */
1051  {
1052  return 2; /* return error */
1053  }
1054  if (handle->inited != 1) /* check handle initialization */
1055  {
1056  return 3; /* return error */
1057  }
1058 
1059  buf[0] = AS608_COMMAND_LOAD_CHAR; /* load char */
1060  buf[1] = num; /* set buffer number */
1061  buf[2] = (page_number >> 8) & 0xFF; /* page number msb */
1062  buf[3] = (page_number >> 0) & 0xFF; /* page number lsb */
1063  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 4); /* write data */
1064  if (res != 0) /* check result */
1065  {
1066  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1067 
1068  return 1; /* return error */
1069  }
1070  len = 1; /* len 1 */
1071  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
1072  if (res != 0) /* check result */
1073  {
1074  return 4; /* return error */
1075  }
1076  if (addr_check != addr) /* check addr */
1077  {
1078  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
1079 
1080  return 5; /* return error */
1081  }
1082  if (len != 1) /* check length */
1083  {
1084  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
1085 
1086  return 6; /* return error */
1087  }
1088  handle->status = buf[0]; /* save status */
1089  *status = (as608_status_t)handle->status; /* set status */
1090 
1091  return 0; /* success return 0 */
1092 }
1093 
1113 uint8_t as608_upload_feature(as608_handle_t *handle, uint32_t addr, as608_buffer_number_t num,
1114  uint8_t *output_buffer, uint16_t *output_len, as608_status_t *status)
1115 {
1116  uint8_t res;
1117  uint8_t buf[2];
1118  uint16_t l;
1119  uint16_t point;
1120  uint16_t len;
1121  uint32_t addr_check;
1122 
1123  if (handle == NULL) /* check handle */
1124  {
1125  return 2; /* return error */
1126  }
1127  if (handle->inited != 1) /* check handle initialization */
1128  {
1129  return 3; /* return error */
1130  }
1131 
1132  buf[0] = AS608_COMMAND_UP_CHAR; /* upload char */
1133  buf[1] = num; /* set buffer number */
1134  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 2); /* write data */
1135  if (res != 0) /* check result */
1136  {
1137  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1138 
1139  return 1; /* return error */
1140  }
1141  len = 1; /* len 1 */
1142  res = a_as608_uart_decode_with_length(handle, 12, 100, &addr_check,
1143  buf, &len); /* decode */
1144  if (res != 0) /* check result */
1145  {
1146  return 4; /* return error */
1147  }
1148  if (addr_check != addr) /* check addr */
1149  {
1150  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
1151 
1152  return 5; /* return error */
1153  }
1154  if (len != 1) /* check length */
1155  {
1156  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
1157 
1158  return 6; /* return error */
1159  }
1160  handle->status = buf[0]; /* save status */
1161  *status = (as608_status_t)handle->status; /* set status */
1162  point = 0; /* init 0 */
1163  len = *output_len; /* get the length */
1164  l = *output_len; /* get the length */
1165  while (1) /* loop */
1166  {
1167  as608_bool_t end_enable;
1168  as608_bool_t full_enable;
1169 
1170  l = len; /* set the remain max buffer size */
1171  res = a_as608_uart_parse_data(handle, 100, &addr_check,
1172  output_buffer + point,
1173  &l, &end_enable, &full_enable); /* parse the data */
1174  if (res != 0)
1175  {
1176  return 4; /* return error */
1177  }
1178  if (addr_check != addr) /* check addr */
1179  {
1180  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
1181 
1182  return 5; /* return error */
1183  }
1184  len -= l; /* remain length - read length */
1185  point += l; /* current point adds read length */
1186  if (full_enable == AS608_BOOL_TRUE) /* if buffer is full */
1187  {
1188  handle->debug_print("as608: buffer is full.\n"); /* buffer is full */
1189 
1190  return 7; /* return error */
1191  }
1192  if (end_enable == AS608_BOOL_TRUE) /* if the last packet */
1193  {
1194  break; /* break */
1195  }
1196  }
1197  *output_len = point; /* save the length */
1198 
1199  return 0; /* success return 0 */
1200 }
1201 
1220 uint8_t as608_download_feature(as608_handle_t *handle, uint32_t addr, as608_buffer_number_t num,
1221  uint8_t *input_buffer, uint16_t input_len, as608_status_t *status)
1222 {
1223  uint8_t res;
1224  uint8_t buf[2];
1225  uint16_t i;
1226  uint16_t m;
1227  uint16_t n;
1228  uint16_t len;
1229  uint32_t addr_check;
1230 
1231  if (handle == NULL) /* check handle */
1232  {
1233  return 2; /* return error */
1234  }
1235  if (handle->inited != 1) /* check handle initialization */
1236  {
1237  return 3; /* return error */
1238  }
1239 
1240  buf[0] = AS608_COMMAND_DOWN_CHAR; /* download char */
1241  buf[1] = num; /* set buffer number */
1242  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 2); /* write data */
1243  if (res != 0) /* check result */
1244  {
1245  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1246 
1247  return 1; /* return error */
1248  }
1249  len = 1; /* len 1 */
1250  res = a_as608_uart_decode_with_length(handle, 12, 100, &addr_check, buf, &len); /* decode */
1251  if (res != 0) /* check result */
1252  {
1253  return 4; /* return error */
1254  }
1255  if (addr_check != addr) /* check addr */
1256  {
1257  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
1258 
1259  return 5; /* return error */
1260  }
1261  if (len != 1) /* check length */
1262  {
1263  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
1264 
1265  return 6; /* return error */
1266  }
1267  handle->status = buf[0]; /* save status */
1268  *status = (as608_status_t)handle->status; /* set status */
1269 
1270  m = input_len / handle->packet_size; /* set m */
1271  n = input_len % handle->packet_size; /* set n */
1272  if (n != 0) /* check n */
1273  {
1274  for (i = 0; i < m; i++) /* m times */
1275  {
1276  res = a_as608_uart_write(handle, addr, AS608_TYPE_DATA,
1277  input_buffer + i * handle->packet_size,
1278  handle->packet_size); /* write data */
1279  if (res != 0) /* check result */
1280  {
1281  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1282 
1283  return 1; /* return error */
1284  }
1285  handle->delay_ms(100); /* delay 100ms */
1286  }
1287  res = a_as608_uart_write(handle, addr, AS608_TYPE_END,
1288  input_buffer + m * handle->packet_size, n); /* write data */
1289  if (res != 0) /* check result */
1290  {
1291  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1292 
1293  return 1; /* return error */
1294  }
1295  handle->delay_ms(100); /* delay 100ms */
1296  }
1297  else
1298  {
1299  for (i = 0; i < (m - 1); i++) /* m - 1 times */
1300  {
1301  res = a_as608_uart_write(handle, addr, AS608_TYPE_DATA,
1302  input_buffer + i * handle->packet_size,
1303  handle->packet_size); /* write data */
1304  if (res != 0) /* check result */
1305  {
1306  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1307 
1308  return 1; /* return error */
1309  }
1310  handle->delay_ms(100); /* delay 100ms */
1311  }
1312  res = a_as608_uart_write(handle, addr, AS608_TYPE_END,
1313  input_buffer + (m - 1) * handle->packet_size,
1314  handle->packet_size); /* write data */
1315  if (res != 0) /* check result */
1316  {
1317  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1318 
1319  return 1; /* return error */
1320  }
1321  handle->delay_ms(100); /* delay 100ms */
1322  }
1323 
1324  return 0; /* success return 0 */
1325 }
1326 
1345 uint8_t as608_upload_image(as608_handle_t *handle, uint32_t addr, uint8_t *output_buffer,
1346  uint16_t *output_len, as608_status_t *status)
1347 {
1348  uint8_t res;
1349  uint8_t buf[1];
1350  uint16_t l;
1351  uint16_t point;
1352  uint16_t len;
1353  uint32_t addr_check;
1354 
1355  if (handle == NULL) /* check handle */
1356  {
1357  return 2; /* return error */
1358  }
1359  if (handle->inited != 1) /* check handle initialization */
1360  {
1361  return 3; /* return error */
1362  }
1363 
1364  buf[0] = AS608_COMMAND_UP_IMAGE; /* upload image */
1365  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 1); /* write data */
1366  if (res != 0) /* check result */
1367  {
1368  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1369 
1370  return 1; /* return error */
1371  }
1372  len = 1; /* len 1 */
1373  res = a_as608_uart_decode_with_length(handle, 12, 100,
1374  &addr_check, buf, &len); /* decode */
1375  if (res != 0) /* check result */
1376  {
1377  return 4; /* return error */
1378  }
1379  if (addr_check != addr) /* check addr */
1380  {
1381  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
1382 
1383  return 5; /* return error */
1384  }
1385  if (len != 1) /* check length */
1386  {
1387  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
1388 
1389  return 6; /* return error */
1390  }
1391  handle->status = buf[0]; /* save status */
1392  *status = (as608_status_t)handle->status; /* set status */
1393  point = 0; /* init 0 */
1394  len = *output_len; /* get the length */
1395  l = *output_len; /* get the length */
1396  while (1) /* loop */
1397  {
1398  as608_bool_t end_enable;
1399  as608_bool_t full_enable;
1400 
1401  l = len; /* set the remain max buffer size */
1402  res = a_as608_uart_parse_data(handle, 100, &addr_check,
1403  output_buffer + point,
1404  &l, &end_enable, &full_enable); /* parse the data */
1405  if (res != 0)
1406  {
1407  return 4; /* return error */
1408  }
1409  if (addr_check != addr) /* check addr */
1410  {
1411  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
1412 
1413  return 5; /* return error */
1414  }
1415  len -= l; /* remain length - read length */
1416  point += l; /* current point adds read length */
1417  if (full_enable == AS608_BOOL_TRUE) /* if buffer is full */
1418  {
1419  handle->debug_print("as608: buffer is full.\n"); /* buffer is full */
1420 
1421  return 7; /* return error */
1422  }
1423  if (end_enable == AS608_BOOL_TRUE) /* if the last packet */
1424  {
1425  break; /* break */
1426  }
1427  }
1428  *output_len = point; /* save the length */
1429 
1430  return 0; /* success return 0 */
1431 }
1432 
1450 uint8_t as608_download_image(as608_handle_t *handle, uint32_t addr, uint8_t *input_buffer,
1451  uint16_t input_len, as608_status_t *status)
1452 {
1453  uint8_t res;
1454  uint8_t buf[1];
1455  uint16_t i;
1456  uint16_t m;
1457  uint16_t n;
1458  uint16_t len;
1459  uint32_t addr_check;
1460 
1461  if (handle == NULL) /* check handle */
1462  {
1463  return 2; /* return error */
1464  }
1465  if (handle->inited != 1) /* check handle initialization */
1466  {
1467  return 3; /* return error */
1468  }
1469 
1470  buf[0] = AS608_COMMAND_DOWN_IMAGE; /* download char */
1471  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 1); /* write data */
1472  if (res != 0) /* check result */
1473  {
1474  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1475 
1476  return 1; /* return error */
1477  }
1478  len = 1; /* len 1 */
1479  res = a_as608_uart_decode_with_length(handle, 12, 100, &addr_check, buf, &len); /* decode */
1480  if (res != 0) /* check result */
1481  {
1482  return 4; /* return error */
1483  }
1484  if (addr_check != addr) /* check addr */
1485  {
1486  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
1487 
1488  return 5; /* return error */
1489  }
1490  if (len != 1) /* check length */
1491  {
1492  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
1493 
1494  return 6; /* return error */
1495  }
1496  handle->status = buf[0]; /* save status */
1497  *status = (as608_status_t)handle->status; /* set status */
1498 
1499  m = input_len / handle->packet_size; /* set m */
1500  n = input_len % handle->packet_size; /* set n */
1501  if (n != 0) /* check n */
1502  {
1503  for (i = 0; i < m; i++) /* m times */
1504  {
1505  res = a_as608_uart_write(handle, addr, AS608_TYPE_DATA,
1506  input_buffer + i * handle->packet_size,
1507  handle->packet_size); /* write data */
1508  if (res != 0) /* check result */
1509  {
1510  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1511 
1512  return 1; /* return error */
1513  }
1514  handle->delay_ms(100); /* delay 100ms */
1515  }
1516  res = a_as608_uart_write(handle, addr, AS608_TYPE_END,
1517  input_buffer + m * handle->packet_size, n); /* write data */
1518  if (res != 0) /* check result */
1519  {
1520  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1521 
1522  return 1; /* return error */
1523  }
1524  handle->delay_ms(100); /* delay 100ms */
1525  }
1526  else
1527  {
1528  for (i = 0; i < (m - 1); i++) /* m - 1 times */
1529  {
1530  res = a_as608_uart_write(handle, addr, AS608_TYPE_DATA,
1531  input_buffer + i * handle->packet_size,
1532  handle->packet_size); /* write data */
1533  if (res != 0) /* check result */
1534  {
1535  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1536 
1537  return 1; /* return error */
1538  }
1539  handle->delay_ms(100); /* delay 100ms */
1540  }
1541  res = a_as608_uart_write(handle, addr, AS608_TYPE_END,
1542  input_buffer + (m - 1) * handle->packet_size,
1543  handle->packet_size); /* write data */
1544  if (res != 0) /* check result */
1545  {
1546  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1547 
1548  return 1; /* return error */
1549  }
1550  handle->delay_ms(100); /* delay 100ms */
1551  }
1552 
1553  return 0; /* success return 0 */
1554 }
1555 
1573 uint8_t as608_delete_feature(as608_handle_t *handle, uint32_t addr, uint16_t page_number, uint16_t number, as608_status_t *status)
1574 {
1575  uint8_t res;
1576  uint8_t buf[5];
1577  uint16_t len;
1578  uint32_t addr_check;
1579 
1580  if (handle == NULL) /* check handle */
1581  {
1582  return 2; /* return error */
1583  }
1584  if (handle->inited != 1) /* check handle initialization */
1585  {
1586  return 3; /* return error */
1587  }
1588 
1589  buf[0] = AS608_COMMAND_DELETE_CHAR; /* delete char feature */
1590  buf[1] = (page_number >> 8) & 0xFF; /* page number msb */
1591  buf[2] = (page_number >> 0) & 0xFF; /* page number lsb */
1592  buf[3] = (number >> 8) & 0xFF; /* number msb */
1593  buf[4] = (number >> 0) & 0xFF; /* number lsb */
1594  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 5); /* write data */
1595  if (res != 0) /* check result */
1596  {
1597  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1598 
1599  return 1; /* return error */
1600  }
1601  len = 1; /* len 1 */
1602  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
1603  if (res != 0) /* check result */
1604  {
1605  return 4; /* return error */
1606  }
1607  if (addr_check != addr) /* check addr */
1608  {
1609  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
1610 
1611  return 5; /* return error */
1612  }
1613  if (len != 1) /* check length */
1614  {
1615  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
1616 
1617  return 6; /* return error */
1618  }
1619  handle->status = buf[0]; /* save status */
1620  *status = (as608_status_t)handle->status; /* set status */
1621 
1622  return 0; /* success return 0 */
1623 }
1624 
1640 uint8_t as608_empty_all_feature(as608_handle_t *handle, uint32_t addr, as608_status_t *status)
1641 {
1642  uint8_t res;
1643  uint8_t buf[1];
1644  uint16_t len;
1645  uint32_t addr_check;
1646 
1647  if (handle == NULL) /* check handle */
1648  {
1649  return 2; /* return error */
1650  }
1651  if (handle->inited != 1) /* check handle initialization */
1652  {
1653  return 3; /* return error */
1654  }
1655 
1656  buf[0] = AS608_COMMAND_EMPTY; /* empty all char feature */
1657  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 1); /* write data */
1658  if (res != 0) /* check result */
1659  {
1660  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1661 
1662  return 1; /* return error */
1663  }
1664  len = 1; /* len 1 */
1665  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
1666  if (res != 0) /* check result */
1667  {
1668  return 4; /* return error */
1669  }
1670  if (addr_check != addr) /* check addr */
1671  {
1672  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
1673 
1674  return 5; /* return error */
1675  }
1676  if (len != 1) /* check length */
1677  {
1678  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
1679 
1680  return 6; /* return error */
1681  }
1682  handle->status = buf[0]; /* save status */
1683  *status = (as608_status_t)handle->status; /* set status */
1684 
1685  return 0; /* success return 0 */
1686 }
1687 
1704 uint8_t as608_set_baud_rate(as608_handle_t *handle, uint32_t addr, uint8_t n_9600, as608_status_t *status)
1705 {
1706  uint8_t res;
1707  uint8_t buf[3];
1708  uint16_t len;
1709  uint32_t addr_check;
1710 
1711  if (handle == NULL) /* check handle */
1712  {
1713  return 2; /* return error */
1714  }
1715  if (handle->inited != 1) /* check handle initialization */
1716  {
1717  return 3; /* return error */
1718  }
1719 
1720  buf[0] = AS608_COMMAND_WRITE_REG; /* write reg */
1721  buf[1] = 0x04; /* baud rate */
1722  buf[2] = n_9600; /* n x 9600 */
1723  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 3); /* write data */
1724  if (res != 0) /* check result */
1725  {
1726  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1727 
1728  return 1; /* return error */
1729  }
1730  len = 1; /* len 1 */
1731  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
1732  if (res != 0) /* check result */
1733  {
1734  return 4; /* return error */
1735  }
1736  if (addr_check != addr) /* check addr */
1737  {
1738  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
1739 
1740  return 5; /* return error */
1741  }
1742  if (len != 1) /* check length */
1743  {
1744  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
1745 
1746  return 6; /* return error */
1747  }
1748  handle->status = buf[0]; /* save status */
1749  *status = (as608_status_t)handle->status; /* set status */
1750 
1751  return 0; /* success return 0 */
1752 }
1753 
1770 uint8_t as608_set_level(as608_handle_t *handle, uint32_t addr, as608_level_t level, as608_status_t *status)
1771 {
1772  uint8_t res;
1773  uint8_t buf[3];
1774  uint16_t len;
1775  uint32_t addr_check;
1776 
1777  if (handle == NULL) /* check handle */
1778  {
1779  return 2; /* return error */
1780  }
1781  if (handle->inited != 1) /* check handle initialization */
1782  {
1783  return 3; /* return error */
1784  }
1785 
1786  buf[0] = AS608_COMMAND_WRITE_REG; /* write reg */
1787  buf[1] = 0x05; /* level settings */
1788  buf[2] = level; /* set level */
1789  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 3); /* write data */
1790  if (res != 0) /* check result */
1791  {
1792  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1793 
1794  return 1; /* return error */
1795  }
1796  len = 1; /* len 1 */
1797  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
1798  if (res != 0) /* check result */
1799  {
1800  return 4; /* return error */
1801  }
1802  if (addr_check != addr) /* check addr */
1803  {
1804  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
1805 
1806  return 5; /* return error */
1807  }
1808  if (len != 1) /* check length */
1809  {
1810  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
1811 
1812  return 6; /* return error */
1813  }
1814  handle->status = buf[0]; /* save status */
1815  *status = (as608_status_t)handle->status; /* set status */
1816 
1817  return 0; /* success return 0 */
1818 }
1819 
1836 uint8_t as608_set_packet_size(as608_handle_t *handle, uint32_t addr, as608_packet_size_t size, as608_status_t *status)
1837 {
1838  uint8_t res;
1839  uint8_t buf[3];
1840  uint16_t len;
1841  uint32_t addr_check;
1842 
1843  if (handle == NULL) /* check handle */
1844  {
1845  return 2; /* return error */
1846  }
1847  if (handle->inited != 1) /* check handle initialization */
1848  {
1849  return 3; /* return error */
1850  }
1851 
1852  buf[0] = AS608_COMMAND_WRITE_REG; /* write reg */
1853  buf[1] = 0x06; /* size settings */
1854  buf[2] = size; /* set size */
1855  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 3); /* write data */
1856  if (res != 0) /* check result */
1857  {
1858  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1859 
1860  return 1; /* return error */
1861  }
1862  len = 1; /* len 1 */
1863  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
1864  if (res != 0) /* check result */
1865  {
1866  return 4; /* return error */
1867  }
1868  if (addr_check != addr) /* check addr */
1869  {
1870  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
1871 
1872  return 5; /* return error */
1873  }
1874  if (len != 1) /* check length */
1875  {
1876  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
1877 
1878  return 6; /* return error */
1879  }
1880  handle->status = buf[0]; /* save status */
1881  *status = (as608_status_t)handle->status; /* set status */
1882  handle->packet_size = (uint16_t)(32.0f * powf(2.0f,
1883  (float)((uint16_t)size))); /* packet size */
1884 
1885  return 0; /* success return 0 */
1886 }
1887 
1904 uint8_t as608_get_params(as608_handle_t *handle, uint32_t addr, as608_params_t *param, as608_status_t *status)
1905 {
1906  uint8_t res;
1907  uint8_t buf[17];
1908  uint16_t len;
1909  uint32_t addr_check;
1910 
1911  if (handle == NULL) /* check handle */
1912  {
1913  return 2; /* return error */
1914  }
1915  if (handle->inited != 1) /* check handle initialization */
1916  {
1917  return 3; /* return error */
1918  }
1919 
1920  buf[0] = AS608_COMMAND_READ_SYS_PARA; /* read sys para */
1921  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 1); /* write data */
1922  if (res != 0) /* check result */
1923  {
1924  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
1925 
1926  return 1; /* return error */
1927  }
1928  len = 17; /* len 17 */
1929  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
1930  if (res != 0) /* check result */
1931  {
1932  return 4; /* return error */
1933  }
1934  if (addr_check != addr) /* check addr */
1935  {
1936  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
1937 
1938  return 5; /* return error */
1939  }
1940  if (len != 17) /* check length */
1941  {
1942  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
1943 
1944  return 6; /* return error */
1945  }
1946  handle->status = buf[0]; /* save status */
1947  *status = (as608_status_t)handle->status; /* set status */
1948  param->status = (uint16_t)((uint16_t)buf[1] << 8) | buf[2]; /* set current status */
1949  param->sensor_type = (as608_sensor_type_t)
1950  ((uint16_t)((uint16_t)buf[3] << 8) | buf[4]); /* set sensor type */
1951  param->fingerprint_size = (uint16_t)((uint16_t)buf[5] << 8) | buf[6]; /* set fingerprint size */
1952  param->level = (as608_level_t)
1953  ((uint16_t)((uint16_t)buf[7] << 8) | buf[8]); /* set level */
1954  param->address = (uint32_t)((uint32_t)buf[9] << 24) |
1955  (uint32_t)((uint32_t)buf[10] << 16) |
1956  (uint32_t)((uint32_t)buf[11] << 8) |
1957  (uint32_t)((uint32_t)buf[12] << 0); /* set address */
1958  param->packet_size = (as608_packet_size_t)
1959  ((uint16_t)((uint16_t)buf[13] << 8) | buf[14]); /* set packet size */
1960  param->n_9600 = (uint16_t)((uint16_t)buf[15] << 8) | buf[16]; /* set n_9600 */
1961 
1962  return 0; /* success return 0 */
1963 }
1964 
1981 uint8_t as608_enroll(as608_handle_t *handle, uint32_t addr, uint16_t *page_number, as608_status_t *status)
1982 {
1983  uint8_t res;
1984  uint8_t buf[3];
1985  uint16_t len;
1986  uint32_t addr_check;
1987 
1988  if (handle == NULL) /* check handle */
1989  {
1990  return 2; /* return error */
1991  }
1992  if (handle->inited != 1) /* check handle initialization */
1993  {
1994  return 3; /* return error */
1995  }
1996 
1997  buf[0] = AS608_COMMAND_ENROLL; /* enroll */
1998  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 1); /* write data */
1999  if (res != 0) /* check result */
2000  {
2001  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2002 
2003  return 1; /* return error */
2004  }
2005  len = 3; /* len 3 */
2006  res = a_as608_uart_decode(handle, 1000, &addr_check, buf, &len); /* decode */
2007  if (res != 0) /* check result */
2008  {
2009  return 4; /* return error */
2010  }
2011  if (addr_check != addr) /* check addr */
2012  {
2013  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
2014 
2015  return 5; /* return error */
2016  }
2017  if (len != 3) /* check length */
2018  {
2019  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
2020 
2021  return 6; /* return error */
2022  }
2023  handle->status = buf[0]; /* save status */
2024  *status = (as608_status_t)handle->status; /* set status */
2025  *page_number = (uint16_t)((uint16_t)buf[1]) | buf[2]; /* set page number */
2026 
2027  return 0; /* success return 0 */
2028 }
2029 
2047 uint8_t as608_identify(as608_handle_t *handle, uint32_t addr, uint16_t *page_number, uint16_t *score, as608_status_t *status)
2048 {
2049  uint8_t res;
2050  uint8_t buf[5];
2051  uint16_t len;
2052  uint32_t addr_check;
2053 
2054  if (handle == NULL) /* check handle */
2055  {
2056  return 2; /* return error */
2057  }
2058  if (handle->inited != 1) /* check handle initialization */
2059  {
2060  return 3; /* return error */
2061  }
2062 
2063  buf[0] = AS608_COMMAND_IDENTIFY; /* identify */
2064  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 1); /* write data */
2065  if (res != 0) /* check result */
2066  {
2067  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2068 
2069  return 1; /* return error */
2070  }
2071  len = 5; /* len 5 */
2072  res = a_as608_uart_decode(handle, 1000, &addr_check, buf, &len); /* decode */
2073  if (res != 0) /* check result */
2074  {
2075  return 4; /* return error */
2076  }
2077  if (addr_check != addr) /* check addr */
2078  {
2079  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
2080 
2081  return 5; /* return error */
2082  }
2083  if (len != 5) /* check length */
2084  {
2085  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
2086 
2087  return 6; /* return error */
2088  }
2089  handle->status = buf[0]; /* save status */
2090  *status = (as608_status_t)handle->status; /* set status */
2091  *page_number = (uint16_t)((uint16_t)buf[1]) | buf[2]; /* set page number */
2092  *score = (uint16_t)((uint16_t)buf[3]) | buf[4]; /* set score */
2093 
2094  return 0; /* success return 0 */
2095 }
2096 
2113 uint8_t as608_set_password(as608_handle_t *handle, uint32_t addr, uint32_t password, as608_status_t *status)
2114 {
2115  uint8_t res;
2116  uint8_t buf[5];
2117  uint16_t len;
2118  uint32_t addr_check;
2119 
2120  if (handle == NULL) /* check handle */
2121  {
2122  return 2; /* return error */
2123  }
2124  if (handle->inited != 1) /* check handle initialization */
2125  {
2126  return 3; /* return error */
2127  }
2128 
2129  buf[0] = AS608_COMMAND_SET_PWD; /* set password */
2130  buf[1] = (password >> 24) & 0xFF; /* set password */
2131  buf[2] = (password >> 16) & 0xFF; /* set password */
2132  buf[3] = (password >> 8) & 0xFF; /* set password */
2133  buf[4] = (password >> 0) & 0xFF; /* set password */
2134  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 5); /* write data */
2135  if (res != 0) /* check result */
2136  {
2137  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2138 
2139  return 1; /* return error */
2140  }
2141  len = 1; /* len 1 */
2142  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
2143  if (res != 0) /* check result */
2144  {
2145  return 4; /* return error */
2146  }
2147  if (addr_check != addr) /* check addr */
2148  {
2149  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
2150 
2151  return 5; /* return error */
2152  }
2153  if (len != 1) /* check length */
2154  {
2155  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
2156 
2157  return 6; /* return error */
2158  }
2159  handle->status = buf[0]; /* save status */
2160  *status = (as608_status_t)handle->status; /* set status */
2161 
2162  return 0; /* success return 0 */
2163 }
2164 
2181 uint8_t as608_verify_password(as608_handle_t *handle, uint32_t addr, uint32_t password, as608_status_t *status)
2182 {
2183  uint8_t res;
2184  uint8_t buf[5];
2185  uint16_t len;
2186  uint32_t addr_check;
2187 
2188  if (handle == NULL) /* check handle */
2189  {
2190  return 2; /* return error */
2191  }
2192  if (handle->inited != 1) /* check handle initialization */
2193  {
2194  return 3; /* return error */
2195  }
2196 
2197  buf[0] = AS608_COMMAND_VFY_PWD; /* verify password */
2198  buf[1] = (password >> 24) & 0xFF; /* set password */
2199  buf[2] = (password >> 16) & 0xFF; /* set password */
2200  buf[3] = (password >> 8) & 0xFF; /* set password */
2201  buf[4] = (password >> 0) & 0xFF; /* set password */
2202  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 5); /* write data */
2203  if (res != 0) /* check result */
2204  {
2205  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2206 
2207  return 1; /* return error */
2208  }
2209  len = 1; /* len 1 */
2210  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
2211  if (res != 0) /* check result */
2212  {
2213  return 4; /* return error */
2214  }
2215  if (addr_check != addr) /* check addr */
2216  {
2217  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
2218 
2219  return 5; /* return error */
2220  }
2221  if (len != 1) /* check length */
2222  {
2223  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
2224 
2225  return 6; /* return error */
2226  }
2227  handle->status = buf[0]; /* save status */
2228  *status = (as608_status_t)handle->status; /* set status */
2229 
2230  return 0; /* success return 0 */
2231 }
2232 
2249 uint8_t as608_get_random(as608_handle_t *handle, uint32_t addr, uint32_t *randn, as608_status_t *status)
2250 {
2251  uint8_t res;
2252  uint8_t buf[5];
2253  uint16_t len;
2254  uint32_t addr_check;
2255 
2256  if (handle == NULL) /* check handle */
2257  {
2258  return 2; /* return error */
2259  }
2260  if (handle->inited != 1) /* check handle initialization */
2261  {
2262  return 3; /* return error */
2263  }
2264 
2265  buf[0] = AS608_COMMAND_GET_RANDOM_CODE; /* get random code */
2266  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 1); /* write data */
2267  if (res != 0) /* check result */
2268  {
2269  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2270 
2271  return 1; /* return error */
2272  }
2273  len = 5; /* len 5 */
2274  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
2275  if (res != 0) /* check result */
2276  {
2277  return 4; /* return error */
2278  }
2279  if (addr_check != addr) /* check addr */
2280  {
2281  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
2282 
2283  return 5; /* return error */
2284  }
2285  if (len != 5) /* check length */
2286  {
2287  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
2288 
2289  return 6; /* return error */
2290  }
2291  handle->status = buf[0]; /* save status */
2292  *status = (as608_status_t)handle->status; /* set status */
2293  *randn = (uint32_t)((uint32_t)buf[1] << 24) |
2294  (uint32_t)((uint32_t)buf[2] << 16) |
2295  (uint32_t)((uint32_t)buf[3] << 8) |
2296  (uint32_t)((uint32_t)buf[4] << 0); /* get the random */
2297 
2298  return 0; /* success return 0 */
2299 }
2300 
2317 uint8_t as608_set_chip_address(as608_handle_t *handle, uint32_t addr, uint32_t new_addr, as608_status_t *status)
2318 {
2319  uint8_t res;
2320  uint8_t buf[5];
2321  uint16_t len;
2322  uint32_t addr_check;
2323 
2324  if (handle == NULL) /* check handle */
2325  {
2326  return 2; /* return error */
2327  }
2328  if (handle->inited != 1) /* check handle initialization */
2329  {
2330  return 3; /* return error */
2331  }
2332 
2333  buf[0] = AS608_COMMAND_SET_CHIP_ADDR; /* set chip addr */
2334  buf[1] = (new_addr >> 24) & 0xFF; /* set chip addr */
2335  buf[2] = (new_addr >> 16) & 0xFF; /* set chip addr*/
2336  buf[3] = (new_addr >> 8) & 0xFF; /* set chip addr */
2337  buf[4] = (new_addr >> 0) & 0xFF; /* set chip addr */
2338  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 5); /* write data */
2339  if (res != 0) /* check result */
2340  {
2341  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2342 
2343  return 1; /* return error */
2344  }
2345  len = 1; /* len 1 */
2346  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
2347  if (res != 0) /* check result */
2348  {
2349  return 4; /* return error */
2350  }
2351  if (addr_check != new_addr) /* check addr */
2352  {
2353  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
2354 
2355  return 5; /* return error */
2356  }
2357  if (len != 1) /* check length */
2358  {
2359  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
2360 
2361  return 6; /* return error */
2362  }
2363  handle->status = buf[0]; /* save status */
2364  *status = (as608_status_t)handle->status; /* set status */
2365 
2366  return 0; /* success return 0 */
2367 }
2368 
2387 uint8_t as608_get_flash_information(as608_handle_t *handle, uint32_t addr,
2388  uint8_t *output_buffer, uint16_t *output_len, as608_status_t *status)
2389 {
2390  uint8_t res;
2391  uint8_t buf[1];
2392  uint16_t l;
2393  uint16_t point;
2394  uint16_t len;
2395  uint32_t addr_check;
2396 
2397  if (handle == NULL) /* check handle */
2398  {
2399  return 2; /* return error */
2400  }
2401  if (handle->inited != 1) /* check handle initialization */
2402  {
2403  return 3; /* return error */
2404  }
2405 
2406  buf[0] = AS608_COMMAND_READ_INFO_PAGE; /* read info page */
2407  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 1); /* write data */
2408  if (res != 0) /* check result */
2409  {
2410  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2411 
2412  return 1; /* return error */
2413  }
2414  len = 1; /* len 1 */
2415  res = a_as608_uart_decode_with_length(handle, 12, 100, &addr_check,
2416  buf, &len); /* decode */
2417  if (res != 0) /* check result */
2418  {
2419  return 4; /* return error */
2420  }
2421  if (addr_check != addr) /* check addr */
2422  {
2423  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
2424 
2425  return 5; /* return error */
2426  }
2427  if (len != 1) /* check length */
2428  {
2429  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
2430 
2431  return 6; /* return error */
2432  }
2433  handle->status = buf[0]; /* save status */
2434  *status = (as608_status_t)handle->status; /* set status */
2435  point = 0; /* init 0 */
2436  len = *output_len; /* get the length */
2437  l = *output_len; /* get the length */
2438  while (1) /* loop */
2439  {
2440  as608_bool_t end_enable;
2441  as608_bool_t full_enable;
2442 
2443  l = len; /* set the remain max buffer size */
2444  res = a_as608_uart_parse_data(handle, 100, &addr_check,
2445  output_buffer + point,
2446  &l, &end_enable, &full_enable); /* parse the data */
2447  if (res != 0)
2448  {
2449  return 4; /* return error */
2450  }
2451  if (addr_check != addr) /* check addr */
2452  {
2453  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
2454 
2455  return 5; /* return error */
2456  }
2457  len -= l; /* remain length - read length */
2458  point += l; /* current point adds read length */
2459  if (full_enable == AS608_BOOL_TRUE) /* if buffer is full */
2460  {
2461  handle->debug_print("as608: buffer is full.\n"); /* buffer is full */
2462 
2463  return 7; /* return error */
2464  }
2465  if (end_enable == AS608_BOOL_TRUE) /* if the last packet */
2466  {
2467  break; /* break */
2468  }
2469  }
2470  *output_len = point; /* save the length */
2471 
2472  return 0; /* success return 0 */
2473 }
2474 
2491 uint8_t as608_set_port(as608_handle_t *handle, uint32_t addr, as608_bool_t enable, as608_status_t *status)
2492 {
2493  uint8_t res;
2494  uint8_t buf[2];
2495  uint16_t len;
2496  uint32_t addr_check;
2497 
2498  if (handle == NULL) /* check handle */
2499  {
2500  return 2; /* return error */
2501  }
2502  if (handle->inited != 1) /* check handle initialization */
2503  {
2504  return 3; /* return error */
2505  }
2506 
2507  buf[0] = AS608_COMMAND_PORT_CONTROL; /* port control */
2508  buf[1] = enable; /* set chip addr */
2509  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 2); /* write data */
2510  if (res != 0) /* check result */
2511  {
2512  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2513 
2514  return 1; /* return error */
2515  }
2516  len = 1; /* len 1 */
2517  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
2518  if (res != 0) /* check result */
2519  {
2520  return 4; /* return error */
2521  }
2522  if (addr_check != addr) /* check addr */
2523  {
2524  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
2525 
2526  return 5; /* return error */
2527  }
2528  if (len != 1) /* check length */
2529  {
2530  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
2531 
2532  return 6; /* return error */
2533  }
2534  handle->status = buf[0]; /* save status */
2535  *status = (as608_status_t)handle->status; /* set status */
2536 
2537  return 0; /* success return 0 */
2538 }
2539 
2558 uint8_t as608_write_notepad(as608_handle_t *handle, uint32_t addr, uint8_t page_number, uint8_t data[32], as608_status_t *status)
2559 {
2560  uint8_t res;
2561  uint8_t buf[34];
2562  uint16_t len;
2563  uint32_t addr_check;
2564 
2565  if (handle == NULL) /* check handle */
2566  {
2567  return 2; /* return error */
2568  }
2569  if (handle->inited != 1) /* check handle initialization */
2570  {
2571  return 3; /* return error */
2572  }
2573  if (page_number > 16) /* check page number */
2574  {
2575  handle->debug_print("as608: page_number > 16.\n"); /* page_number > 16 */
2576 
2577  return 7; /* return error */
2578  }
2579 
2580  buf[0] = AS608_COMMAND_WRITE_NOTEPAD; /* write notepad */
2581  buf[1] = page_number; /* set page number */
2582  memcpy(&buf[2], data, 32); /* copy data */
2583  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 34); /* write data */
2584  if (res != 0) /* check result */
2585  {
2586  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2587 
2588  return 1; /* return error */
2589  }
2590  len = 1; /* len 1 */
2591  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
2592  if (res != 0) /* check result */
2593  {
2594  return 4; /* return error */
2595  }
2596  if (addr_check != addr) /* check addr */
2597  {
2598  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
2599 
2600  return 5; /* return error */
2601  }
2602  if (len != 1) /* check length */
2603  {
2604  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
2605 
2606  return 6; /* return error */
2607  }
2608  handle->status = buf[0]; /* save status */
2609  *status = (as608_status_t)handle->status; /* set status */
2610 
2611  return 0; /* success return 0 */
2612 }
2613 
2632 uint8_t as608_read_notepad(as608_handle_t *handle, uint32_t addr, uint8_t page_number, uint8_t data[32], as608_status_t *status)
2633 {
2634  uint8_t res;
2635  uint8_t buf[33];
2636  uint16_t len;
2637  uint32_t addr_check;
2638 
2639  if (handle == NULL) /* check handle */
2640  {
2641  return 2; /* return error */
2642  }
2643  if (handle->inited != 1) /* check handle initialization */
2644  {
2645  return 3; /* return error */
2646  }
2647  if (page_number > 16) /* check page number */
2648  {
2649  handle->debug_print("as608: page_number > 16.\n"); /* page_number > 16 */
2650 
2651  return 7; /* return error */
2652  }
2653 
2654  buf[0] = AS608_COMMAND_READ_NOTEPAD; /* read notepad */
2655  buf[1] = page_number; /* set page number */
2656  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 2); /* write data */
2657  if (res != 0) /* check result */
2658  {
2659  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2660 
2661  return 1; /* return error */
2662  }
2663  len = 33; /* len 33 */
2664  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
2665  if (res != 0) /* check result */
2666  {
2667  return 4; /* return error */
2668  }
2669  if (addr_check != addr) /* check addr */
2670  {
2671  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
2672 
2673  return 5; /* return error */
2674  }
2675  if (len != 33) /* check length */
2676  {
2677  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
2678 
2679  return 6; /* return error */
2680  }
2681  handle->status = buf[0]; /* save status */
2682  *status = (as608_status_t)handle->status; /* set status */
2683  memcpy(data, &buf[1], 32); /* copy data */
2684 
2685  return 0; /* success return 0 */
2686 }
2687 
2706 uint8_t as608_burn_code(as608_handle_t *handle, uint32_t addr, as608_burn_code_mode_t mode,
2707  uint8_t *input_buffer, uint16_t input_len, as608_status_t *status)
2708 {
2709  uint8_t res;
2710  uint8_t buf[2];
2711  uint16_t i;
2712  uint16_t m;
2713  uint16_t n;
2714  uint16_t len;
2715  uint32_t addr_check;
2716 
2717  if (handle == NULL) /* check handle */
2718  {
2719  return 2; /* return error */
2720  }
2721  if (handle->inited != 1) /* check handle initialization */
2722  {
2723  return 3; /* return error */
2724  }
2725 
2726  buf[0] = AS608_COMMAND_BURN_CODE; /* burn code */
2727  buf[1] = mode; /* set burn code */
2728  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 2); /* write data */
2729  if (res != 0) /* check result */
2730  {
2731  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2732 
2733  return 1; /* return error */
2734  }
2735  len = 1; /* len 1 */
2736  res = a_as608_uart_decode_with_length(handle, 12, 100, &addr_check, buf, &len); /* decode */
2737  if (res != 0) /* check result */
2738  {
2739  return 4; /* return error */
2740  }
2741  if (addr_check != addr) /* check addr */
2742  {
2743  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
2744 
2745  return 5; /* return error */
2746  }
2747  if (len != 1) /* check length */
2748  {
2749  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
2750 
2751  return 6; /* return error */
2752  }
2753  handle->status = buf[0]; /* save status */
2754  *status = (as608_status_t)handle->status; /* set status */
2755 
2756  m = input_len / handle->packet_size; /* set m */
2757  n = input_len % handle->packet_size; /* set n */
2758  if (n != 0) /* check n */
2759  {
2760  for (i = 0; i < m; i++) /* m times */
2761  {
2762  res = a_as608_uart_write(handle, addr, AS608_TYPE_DATA,
2763  input_buffer + i * handle->packet_size,
2764  handle->packet_size); /* write data */
2765  if (res != 0) /* check result */
2766  {
2767  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2768 
2769  return 1; /* return error */
2770  }
2771  handle->delay_ms(100); /* delay 100ms */
2772  }
2773  res = a_as608_uart_write(handle, addr, AS608_TYPE_END,
2774  input_buffer + m * handle->packet_size, n); /* write data */
2775  if (res != 0) /* check result */
2776  {
2777  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2778 
2779  return 1; /* return error */
2780  }
2781  handle->delay_ms(100); /* delay 100ms */
2782  }
2783  else
2784  {
2785  for (i = 0; i < (m - 1); i++) /* m - 1 times */
2786  {
2787  res = a_as608_uart_write(handle, addr, AS608_TYPE_DATA,
2788  input_buffer + i * handle->packet_size,
2789  handle->packet_size); /* write data */
2790  if (res != 0) /* check result */
2791  {
2792  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2793 
2794  return 1; /* return error */
2795  }
2796  handle->delay_ms(100); /* delay 100ms */
2797  }
2798  res = a_as608_uart_write(handle, addr, AS608_TYPE_END,
2799  input_buffer + (m - 1) * handle->packet_size,
2800  handle->packet_size); /* write data */
2801  if (res != 0) /* check result */
2802  {
2803  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2804 
2805  return 1; /* return error */
2806  }
2807  handle->delay_ms(100); /* delay 100ms */
2808  }
2809 
2810  return 0; /* success return 0 */
2811 }
2812 
2833 uint8_t as608_high_speed_search(as608_handle_t *handle, uint32_t addr, as608_buffer_number_t buffer_number,
2834  uint16_t start_page, uint16_t page_number,
2835  uint16_t *found_page, uint16_t *score,
2836  as608_status_t *status)
2837 {
2838  uint8_t res;
2839  uint8_t buf[6];
2840  uint16_t len;
2841  uint32_t addr_check;
2842 
2843  if (handle == NULL) /* check handle */
2844  {
2845  return 2; /* return error */
2846  }
2847  if (handle->inited != 1) /* check handle initialization */
2848  {
2849  return 3; /* return error */
2850  }
2851 
2852  buf[0] = AS608_COMMAND_HIGH_SPEED_SEARCH; /* high speed search */
2853  buf[1] = buffer_number; /* set buffer number */
2854  buf[2] = (start_page >> 8) & 0xFF; /* start page msb */
2855  buf[3] = (start_page >> 0) & 0xFF; /* start page lsb */
2856  buf[4] = (page_number >> 8) & 0xFF; /* page number msb */
2857  buf[5] = (page_number >> 0) & 0xFF; /* page number lsb */
2858  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 6); /* write data */
2859  if (res != 0) /* check result */
2860  {
2861  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2862 
2863  return 1; /* return error */
2864  }
2865  len = 5; /* len 5 */
2866  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
2867  if (res != 0) /* check result */
2868  {
2869  return 4; /* return error */
2870  }
2871  if (addr_check != addr) /* check addr */
2872  {
2873  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
2874 
2875  return 5; /* return error */
2876  }
2877  if (len != 5) /* check length */
2878  {
2879  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
2880 
2881  return 6; /* return error */
2882  }
2883  handle->status = buf[0]; /* save status */
2884  *status = (as608_status_t)handle->status; /* set status */
2885  *found_page = (uint16_t)((uint16_t)buf[1] << 8) | buf[2]; /* set found page */
2886  *score = (uint16_t)((uint16_t)buf[3] << 8) | buf[4]; /* set score */
2887 
2888  return 0; /* success return 0 */
2889 }
2890 
2907 uint8_t as608_generate_bin_image(as608_handle_t *handle, uint32_t addr, as608_image_t image, as608_status_t *status)
2908 {
2909  uint8_t res;
2910  uint8_t buf[2];
2911  uint16_t len;
2912  uint32_t addr_check;
2913 
2914  if (handle == NULL) /* check handle */
2915  {
2916  return 2; /* return error */
2917  }
2918  if (handle->inited != 1) /* check handle initialization */
2919  {
2920  return 3; /* return error */
2921  }
2922 
2923  buf[0] = AS608_COMMAND_GEN_BIN_IMAGE; /* generate bin image */
2924  buf[1] = image; /* set image */
2925  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 2); /* write data */
2926  if (res != 0) /* check result */
2927  {
2928  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2929 
2930  return 1; /* return error */
2931  }
2932  len = 1; /* len 1 */
2933  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
2934  if (res != 0) /* check result */
2935  {
2936  return 4; /* return error */
2937  }
2938  if (addr_check != addr) /* check addr */
2939  {
2940  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
2941 
2942  return 5; /* return error */
2943  }
2944  if (len != 1) /* check length */
2945  {
2946  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
2947 
2948  return 6; /* return error */
2949  }
2950  handle->status = buf[0]; /* save status */
2951  *status = (as608_status_t)handle->status; /* set status */
2952 
2953  return 0; /* success return 0 */
2954 }
2955 
2972 uint8_t as608_get_valid_template_number(as608_handle_t *handle, uint32_t addr, uint16_t *num, as608_status_t *status)
2973 {
2974  uint8_t res;
2975  uint8_t buf[3];
2976  uint16_t len;
2977  uint32_t addr_check;
2978 
2979  if (handle == NULL) /* check handle */
2980  {
2981  return 2; /* return error */
2982  }
2983  if (handle->inited != 1) /* check handle initialization */
2984  {
2985  return 3; /* return error */
2986  }
2987 
2988  buf[0] = AS608_COMMAND_VALID_TEMPLATE_NUM; /* valid template num */
2989  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 1); /* write data */
2990  if (res != 0) /* check result */
2991  {
2992  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
2993 
2994  return 1; /* return error */
2995  }
2996  len = 3; /* len 3 */
2997  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
2998  if (res != 0) /* check result */
2999  {
3000  return 4; /* return error */
3001  }
3002  if (addr_check != addr) /* check addr */
3003  {
3004  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
3005 
3006  return 5; /* return error */
3007  }
3008  if (len != 3) /* check length */
3009  {
3010  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
3011 
3012  return 6; /* return error */
3013  }
3014  handle->status = buf[0]; /* save status */
3015  *status = (as608_status_t)handle->status; /* set status */
3016  *num = (uint16_t)((uint16_t)buf[1] << 8) | buf[2]; /* get the number */
3017 
3018  return 0; /* success return 0 */
3019 }
3020 
3039 uint8_t as608_set_gpio_level(as608_handle_t *handle, uint32_t addr, as608_gpio_number_t gpio,
3040  as608_gpio_level_t input_level, as608_gpio_level_t *output_level, as608_status_t *status)
3041 {
3042  uint8_t res;
3043  uint8_t buf[3];
3044  uint16_t len;
3045  uint32_t addr_check;
3046 
3047  if (handle == NULL) /* check handle */
3048  {
3049  return 2; /* return error */
3050  }
3051  if (handle->inited != 1) /* check handle initialization */
3052  {
3053  return 3; /* return error */
3054  }
3055 
3056  buf[0] = AS608_COMMAND_USER_GPIO; /* user gpio */
3057  buf[1] = gpio; /* set gpio number */
3058  buf[2] = input_level; /* set gpio input level */
3059  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 3); /* write data */
3060  if (res != 0) /* check result */
3061  {
3062  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
3063 
3064  return 1; /* return error */
3065  }
3066  len = 2; /* len 2 */
3067  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
3068  if (res != 0) /* check result */
3069  {
3070  return 4; /* return error */
3071  }
3072  if (addr_check != addr) /* check addr */
3073  {
3074  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
3075 
3076  return 5; /* return error */
3077  }
3078  if (len != 2) /* check length */
3079  {
3080  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
3081 
3082  return 6; /* return error */
3083  }
3084  handle->status = buf[0]; /* save status */
3085  *status = (as608_status_t)handle->status; /* set status */
3086  *output_level = (as608_gpio_level_t)(buf[1]); /* get gpio level */
3087 
3088  return 0; /* success return 0 */
3089 }
3090 
3109 uint8_t as608_get_index_table(as608_handle_t *handle, uint32_t addr, uint8_t num,
3110  uint8_t table[32], as608_status_t *status)
3111 {
3112  uint8_t res;
3113  uint8_t buf[33];
3114  uint16_t len;
3115  uint32_t addr_check;
3116 
3117  if (handle == NULL) /* check handle */
3118  {
3119  return 2; /* return error */
3120  }
3121  if (handle->inited != 1) /* check handle initialization */
3122  {
3123  return 3; /* return error */
3124  }
3125  if (num > 3) /* check num */
3126  {
3127  handle->debug_print("as608: num > 3.\n"); /* num > 3 */
3128 
3129  return 7; /* return error */
3130  }
3131 
3132  buf[0] = AS608_COMMAND_READ_INDEX_TABLE; /* read index table */
3133  buf[1] = num; /* set index table number */
3134  res = a_as608_uart_write(handle, addr, AS608_TYPE_COMMAND, buf, 2); /* write data */
3135  if (res != 0) /* check result */
3136  {
3137  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
3138 
3139  return 1; /* return error */
3140  }
3141  len = 33; /* len 33 */
3142  res = a_as608_uart_decode(handle, 300, &addr_check, buf, &len); /* decode */
3143  if (res != 0) /* check result */
3144  {
3145  return 4; /* return error */
3146  }
3147  if (addr_check != addr) /* check addr */
3148  {
3149  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
3150 
3151  return 5; /* return error */
3152  }
3153  if (len != 33) /* check length */
3154  {
3155  handle->debug_print("as608: len is invalid.\n"); /* len is invalid */
3156 
3157  return 6; /* return error */
3158  }
3159  handle->status = buf[0]; /* save status */
3160  *status = (as608_status_t)handle->status; /* set status */
3161  memcpy(table, &buf[1], 32); /* copy data */
3162 
3163  return 0; /* success return 0 */
3164 }
3165 
3176 uint8_t as608_print_status(as608_handle_t *handle, as608_status_t status)
3177 {
3178  if (handle == NULL) /* check handle */
3179  {
3180  return 2; /* return error */
3181  }
3182  if (handle->inited != 1) /* check handle initialization */
3183  {
3184  return 3; /* return error */
3185  }
3186 
3187  switch (status) /* switch status */
3188  {
3189  case AS608_STATUS_OK : /* status case */
3190  {
3191  handle->debug_print("as608: ok.\n"); /* print message */
3192 
3193  break; /* break */
3194  }
3195  case AS608_STATUS_FRAME_ERROR : /* status case */
3196  {
3197  handle->debug_print("as608: frame error.\n"); /* print message */
3198 
3199  break; /* break */
3200  }
3201  case AS608_STATUS_NO_FINGERPRINT : /* status case */
3202  {
3203  handle->debug_print("as608: no fingerprint.\n"); /* print message */
3204 
3205  break; /* break */
3206  }
3207  case AS608_STATUS_INPUT_ERROR : /* status case */
3208  {
3209  handle->debug_print("as608: fingerprint image error.\n"); /* print message */
3210 
3211  break; /* break */
3212  }
3213  case AS608_STATUS_IMAGE_TOO_DRY : /* status case */
3214  {
3215  handle->debug_print("as608: fingerprint image too dry.\n"); /* print message */
3216 
3217  break; /* break */
3218  }
3219  case AS608_STATUS_IMAGE_TOO_WET : /* status case */
3220  {
3221  handle->debug_print("as608: fingerprint image too wet.\n"); /* print message */
3222 
3223  break; /* break */
3224  }
3225  case AS608_STATUS_IMAGE_TOO_CLUTTER : /* status case */
3226  {
3227  handle->debug_print("as608: fingerprint too clutter.\n"); /* print message */
3228 
3229  break; /* break */
3230  }
3231  case AS608_STATUS_IMAGE_TOO_FEW_FEATURE : /* status case */
3232  {
3233  handle->debug_print("as608: fingerprint feature too few.\n"); /* print message */
3234 
3235  break; /* break */
3236  }
3237  case AS608_STATUS_NOT_MATCH : /* status case */
3238  {
3239  handle->debug_print("as608: not match.\n"); /* print message */
3240 
3241  break; /* break */
3242  }
3243  case AS608_STATUS_NOT_FOUND : /* status case */
3244  {
3245  handle->debug_print("as608: not found.\n"); /* print message */
3246 
3247  break; /* break */
3248  }
3249  case AS608_STATUS_FEATURE_COMBINE_ERROR : /* status case */
3250  {
3251  handle->debug_print("as608: feature combine error.\n"); /* print message */
3252 
3253  break; /* break */
3254  }
3255  case AS608_STATUS_LIB_ADDR_OVER : /* status case */
3256  {
3257  handle->debug_print("as608: fingerprint lib addr is over.\n"); /* print message */
3258 
3259  break; /* break */
3260  }
3261  case AS608_STATUS_LIB_READ_ERROR : /* status case */
3262  {
3263  handle->debug_print("as608: fingerprint lib read error.\n"); /* print message */
3264 
3265  break; /* break */
3266  }
3267  case AS608_STATUS_UPLOAD_FEATURE_ERROR : /* status case */
3268  {
3269  handle->debug_print("as608: upload feature error.\n"); /* print message */
3270 
3271  break; /* break */
3272  }
3273  case AS608_STATUS_NO_FRAME : /* status case */
3274  {
3275  handle->debug_print("as608: no frame.\n"); /* print message */
3276 
3277  break; /* break */
3278  }
3279  case AS608_STATUS_UPLOAD_IMAGE_ERROR : /* status case */
3280  {
3281  handle->debug_print("as608: upload image error.\n"); /* print message */
3282 
3283  break; /* break */
3284  }
3285  case AS608_STATUS_LIB_DELETE_ERROR : /* status case */
3286  {
3287  handle->debug_print("as608: delete lib error.\n"); /* print message */
3288 
3289  break; /* break */
3290  }
3291  case AS608_STATUS_LIB_CLEAR_ERROR : /* status case */
3292  {
3293  handle->debug_print("as608: clear lib error.\n"); /* print message */
3294 
3295  break; /* break */
3296  }
3297  case AS608_STATUS_ENTER_LOW_POWER_ERROR : /* status case */
3298  {
3299  handle->debug_print("as608: enter low power error.\n"); /* print message */
3300 
3301  break; /* break */
3302  }
3303  case AS608_STATUS_COMMAND_INVALID : /* status case */
3304  {
3305  handle->debug_print("as608: command invalid.\n"); /* print message */
3306 
3307  break; /* break */
3308  }
3309  case AS608_STATUS_RESET_ERROR : /* status case */
3310  {
3311  handle->debug_print("as608: reset error.\n"); /* print message */
3312 
3313  break; /* break */
3314  }
3315  case AS608_STATUS_BUFFER_INVALID : /* status case */
3316  {
3317  handle->debug_print("as608: buffer invalid.\n"); /* print message */
3318 
3319  break; /* break */
3320  }
3321  case AS608_STATUS_UPDATE_ERROR : /* status case */
3322  {
3323  handle->debug_print("as608: update error.\n"); /* print message */
3324 
3325  break; /* break */
3326  }
3327  case AS608_STATUS_NO_MOVE : /* status case */
3328  {
3329  handle->debug_print("as608: no move.\n"); /* print message */
3330 
3331  break; /* break */
3332  }
3333  case AS608_STATUS_FLASH_ERROR : /* status case */
3334  {
3335  handle->debug_print("as608: flash error.\n"); /* print message */
3336 
3337  break; /* break */
3338  }
3339  case AS608_STATUS_F0_RESPONSE : /* status case */
3340  {
3341  handle->debug_print("as608: f0 response.\n"); /* print message */
3342 
3343  break; /* break */
3344  }
3345  case AS608_STATUS_F1_RESPONSE : /* status case */
3346  {
3347  handle->debug_print("as608: f1 response.\n"); /* print message */
3348 
3349  break; /* break */
3350  }
3351  case AS608_STATUS_FLASH_WRITE_SUM_ERROR : /* status case */
3352  {
3353  handle->debug_print("as608: flash sum error.\n"); /* print message */
3354 
3355  break; /* break */
3356  }
3357  case AS608_STATUS_FLASH_WRITE_HEADER_ERROR : /* status case */
3358  {
3359  handle->debug_print("as608: flash header error.\n"); /* print message */
3360 
3361  break; /* break */
3362  }
3363  case AS608_STATUS_FLASH_WRITE_LENGTH_ERROR : /* status case */
3364  {
3365  handle->debug_print("as608: flash length error.\n"); /* print message */
3366 
3367  break; /* break */
3368  }
3369  case AS608_STATUS_FLASH_WRITE_LENGTH_TOO_LONG : /* status case */
3370  {
3371  handle->debug_print("as608: flash length too long.\n"); /* print message */
3372 
3373  break; /* break */
3374  }
3375  case AS608_STATUS_FLASH_WRITE_ERROR : /* status case */
3376  {
3377  handle->debug_print("as608: flash write error.\n"); /* print message */
3378 
3379  break; /* break */
3380  }
3381  case AS608_STATUS_UNKNOWN : /* status case */
3382  {
3383  handle->debug_print("as608: unknown.\n"); /* print message */
3384 
3385  break; /* break */
3386  }
3387  case AS608_STATUS_REG_INVALID : /* status case */
3388  {
3389  handle->debug_print("as608: reg invalid.\n"); /* print message */
3390 
3391  break; /* break */
3392  }
3393  case AS608_STATUS_DATA_INVALID : /* status case */
3394  {
3395  handle->debug_print("as608: data invalid.\n"); /* print message */
3396 
3397  break; /* break */
3398  }
3399  case AS608_STATUS_NOTE_PAGE_INVALID : /* status case */
3400  {
3401  handle->debug_print("as608: note page invalid.\n"); /* print message */
3402 
3403  break; /* break */
3404  }
3405  case AS608_STATUS_PORT_INVALID : /* status case */
3406  {
3407  handle->debug_print("as608: port invalid.\n"); /* print message */
3408 
3409  break; /* break */
3410  }
3411  case AS608_STATUS_ENROOL_ERROR : /* status case */
3412  {
3413  handle->debug_print("as608: enrool error.\n"); /* print message */
3414 
3415  break; /* break */
3416  }
3417  case AS608_STATUS_LIB_FULL : /* status case */
3418  {
3419  handle->debug_print("as608: lib full.\n"); /* print message */
3420 
3421  break; /* break */
3422  }
3423  default : /* default */
3424  {
3425  handle->debug_print("as608: invalid type.\n"); /* print message */
3426 
3427  break; /* break */
3428  }
3429  }
3430 
3431  return 0; /* success return 0 */
3432 }
3433 
3453 uint8_t as608_command_write_read(as608_handle_t *handle, uint32_t addr, uint8_t type,
3454  uint8_t *input_buffer, uint16_t input_len,
3455  uint16_t ms, uint8_t *output_buffer, uint16_t *output_len)
3456 {
3457  uint8_t res;
3458  uint32_t addr_check;
3459 
3460  if (handle == NULL) /* check handle */
3461  {
3462  return 2; /* return error */
3463  }
3464  if (handle->inited != 1) /* check handle initialization */
3465  {
3466  return 3; /* return error */
3467  }
3468 
3469  res = a_as608_uart_write(handle, addr, type, input_buffer, input_len); /* write data */
3470  if (res != 0) /* check result */
3471  {
3472  handle->debug_print("as608: uart write failed.\n"); /* uart write failed */
3473 
3474  return 1; /* return error */
3475  }
3476  res = a_as608_uart_decode(handle, ms, &addr_check, output_buffer, output_len); /* decode*/
3477  if (res != 0) /* check result */
3478  {
3479  return 4; /* return error */
3480  }
3481  if (addr_check != addr) /* check addr */
3482  {
3483  handle->debug_print("as608: addr is invalid.\n"); /* addr is invalid */
3484 
3485  return 5; /* return error */
3486  }
3487 
3488  return 0; /* success return 0 */
3489 }
3490 
3499 uint8_t as608_info(as608_info_t *info)
3500 {
3501  if (info == NULL) /* check handle */
3502  {
3503  return 2; /* return error */
3504  }
3505 
3506  memset(info, 0, sizeof(as608_info_t)); /* initialize as608 info structure */
3507  strncpy(info->chip_name, CHIP_NAME, 32); /* copy chip name */
3508  strncpy(info->manufacturer_name, MANUFACTURER_NAME, 32); /* copy manufacturer name */
3509  strncpy(info->interface, "UART", 8); /* copy interface name */
3510  info->supply_voltage_min_v = SUPPLY_VOLTAGE_MIN; /* set minimal supply voltage */
3511  info->supply_voltage_max_v = SUPPLY_VOLTAGE_MAX; /* set maximum supply voltage */
3512  info->max_current_ma = MAX_CURRENT; /* set maximum current */
3513  info->temperature_max = TEMPERATURE_MAX; /* set minimal temperature */
3514  info->temperature_min = TEMPERATURE_MIN; /* set maximum temperature */
3515  info->driver_version = DRIVER_VERSION; /* set driver version */
3516 
3517  return 0; /* success return 0 */
3518 }
AS608_COMMAND_BURN_CODE
#define AS608_COMMAND_BURN_CODE
Definition: driver_as608.c:80
AS608_COMMAND_REG_MODEL
#define AS608_COMMAND_REG_MODEL
Definition: driver_as608.c:59
AS608_COMMAND_DELETE_CHAR
#define AS608_COMMAND_DELETE_CHAR
Definition: driver_as608.c:66
AS608_COMMAND_DOWN_IMAGE
#define AS608_COMMAND_DOWN_IMAGE
Definition: driver_as608.c:65
AS608_COMMAND_READ_SYS_PARA
#define AS608_COMMAND_READ_SYS_PARA
Definition: driver_as608.c:69
AS608_COMMAND_PORT_CONTROL
#define AS608_COMMAND_PORT_CONTROL
Definition: driver_as608.c:77
MAX_CURRENT
#define MAX_CURRENT
Definition: driver_as608.c:47
AS608_COMMAND_GET_RANDOM_CODE
#define AS608_COMMAND_GET_RANDOM_CODE
Definition: driver_as608.c:74
AS608_COMMAND_MATCH
#define AS608_COMMAND_MATCH
Definition: driver_as608.c:57
AS608_TYPE_RESPONSE
#define AS608_TYPE_RESPONSE
Definition: driver_as608.c:92
AS608_TYPE_END
#define AS608_TYPE_END
Definition: driver_as608.c:93
AS608_COMMAND_DOWN_CHAR
#define AS608_COMMAND_DOWN_CHAR
Definition: driver_as608.c:63
AS608_COMMAND_HIGH_SPEED_SEARCH
#define AS608_COMMAND_HIGH_SPEED_SEARCH
Definition: driver_as608.c:81
AS608_TYPE_COMMAND
#define AS608_TYPE_COMMAND
chip type definition
Definition: driver_as608.c:90
SUPPLY_VOLTAGE_MAX
#define SUPPLY_VOLTAGE_MAX
Definition: driver_as608.c:46
AS608_COMMAND_SEARCH
#define AS608_COMMAND_SEARCH
Definition: driver_as608.c:58
TEMPERATURE_MAX
#define TEMPERATURE_MAX
Definition: driver_as608.c:49
AS608_COMMAND_WRITE_NOTEPAD
#define AS608_COMMAND_WRITE_NOTEPAD
Definition: driver_as608.c:78
AS608_COMMAND_IDENTIFY
#define AS608_COMMAND_IDENTIFY
Definition: driver_as608.c:71
AS608_COMMAND_SET_PWD
#define AS608_COMMAND_SET_PWD
Definition: driver_as608.c:72
AS608_COMMAND_GEN_CHAR
#define AS608_COMMAND_GEN_CHAR
Definition: driver_as608.c:56
AS608_COMMAND_USER_GPIO
#define AS608_COMMAND_USER_GPIO
Definition: driver_as608.c:84
MANUFACTURER_NAME
#define MANUFACTURER_NAME
Definition: driver_as608.c:44
TEMPERATURE_MIN
#define TEMPERATURE_MIN
Definition: driver_as608.c:48
SUPPLY_VOLTAGE_MIN
#define SUPPLY_VOLTAGE_MIN
Definition: driver_as608.c:45
AS608_COMMAND_VFY_PWD
#define AS608_COMMAND_VFY_PWD
Definition: driver_as608.c:73
AS608_COMMAND_LOAD_CHAR
#define AS608_COMMAND_LOAD_CHAR
Definition: driver_as608.c:61
AS608_COMMAND_ENROLL
#define AS608_COMMAND_ENROLL
Definition: driver_as608.c:70
AS608_TYPE_DATA
#define AS608_TYPE_DATA
Definition: driver_as608.c:91
AS608_COMMAND_READ_INDEX_TABLE
#define AS608_COMMAND_READ_INDEX_TABLE
Definition: driver_as608.c:85
AS608_COMMAND_VALID_TEMPLATE_NUM
#define AS608_COMMAND_VALID_TEMPLATE_NUM
Definition: driver_as608.c:83
AS608_COMMAND_READ_INFO_PAGE
#define AS608_COMMAND_READ_INFO_PAGE
Definition: driver_as608.c:76
AS608_COMMAND_EMPTY
#define AS608_COMMAND_EMPTY
Definition: driver_as608.c:67
AS608_COMMAND_READ_NOTEPAD
#define AS608_COMMAND_READ_NOTEPAD
Definition: driver_as608.c:79
CHIP_NAME
#define CHIP_NAME
chip information definition
Definition: driver_as608.c:43
AS608_COMMAND_SET_CHIP_ADDR
#define AS608_COMMAND_SET_CHIP_ADDR
Definition: driver_as608.c:75
AS608_COMMAND_UP_CHAR
#define AS608_COMMAND_UP_CHAR
Definition: driver_as608.c:62
AS608_COMMAND_UP_IMAGE
#define AS608_COMMAND_UP_IMAGE
Definition: driver_as608.c:64
DRIVER_VERSION
#define DRIVER_VERSION
Definition: driver_as608.c:50
AS608_COMMAND_GEN_BIN_IMAGE
#define AS608_COMMAND_GEN_BIN_IMAGE
Definition: driver_as608.c:82
AS608_COMMAND_STORE_CHAR
#define AS608_COMMAND_STORE_CHAR
Definition: driver_as608.c:60
AS608_COMMAND_GET_IMAGE
#define AS608_COMMAND_GET_IMAGE
chip command definition
Definition: driver_as608.c:55
AS608_COMMAND_WRITE_REG
#define AS608_COMMAND_WRITE_REG
Definition: driver_as608.c:68
driver_as608.h
driver as608 header file
as608_download_image
uint8_t as608_download_image(as608_handle_t *handle, uint32_t addr, uint8_t *input_buffer, uint16_t input_len, as608_status_t *status)
download image
Definition: driver_as608.c:1450
as608_sensor_type_t
as608_sensor_type_t
as608 sensor type enumeration definition
Definition: driver_as608.h:104
as608_set_port
uint8_t as608_set_port(as608_handle_t *handle, uint32_t addr, as608_bool_t enable, as608_status_t *status)
enable or disable port
Definition: driver_as608.c:2491
as608_set_packet_size
uint8_t as608_set_packet_size(as608_handle_t *handle, uint32_t addr, as608_packet_size_t size, as608_status_t *status)
set packet size
Definition: driver_as608.c:1836
as608_get_random
uint8_t as608_get_random(as608_handle_t *handle, uint32_t addr, uint32_t *randn, as608_status_t *status)
get random
Definition: driver_as608.c:2249
as608_init
uint8_t as608_init(as608_handle_t *handle, uint32_t addr)
initialize the chip
Definition: driver_as608.c:465
as608_load_feature
uint8_t as608_load_feature(as608_handle_t *handle, uint32_t addr, as608_buffer_number_t num, uint16_t page_number, as608_status_t *status)
load feature
Definition: driver_as608.c:1042
as608_generate_feature
uint8_t as608_generate_feature(as608_handle_t *handle, uint32_t addr, as608_buffer_number_t num, as608_status_t *status)
generate feature
Definition: driver_as608.c:702
as608_get_index_table
uint8_t as608_get_index_table(as608_handle_t *handle, uint32_t addr, uint8_t num, uint8_t table[32], as608_status_t *status)
get index table
Definition: driver_as608.c:3109
as608_store_feature
uint8_t as608_store_feature(as608_handle_t *handle, uint32_t addr, as608_buffer_number_t num, uint16_t page_number, as608_status_t *status)
store feature
Definition: driver_as608.c:973
as608_status_t
as608_status_t
as608 status enumeration definition
Definition: driver_as608.h:153
as608_info
uint8_t as608_info(as608_info_t *info)
get chip's information
Definition: driver_as608.c:3499
as608_set_password
uint8_t as608_set_password(as608_handle_t *handle, uint32_t addr, uint32_t password, as608_status_t *status)
set password
Definition: driver_as608.c:2113
as608_upload_image
uint8_t as608_upload_image(as608_handle_t *handle, uint32_t addr, uint8_t *output_buffer, uint16_t *output_len, as608_status_t *status)
upload image
Definition: driver_as608.c:1345
as608_write_notepad
uint8_t as608_write_notepad(as608_handle_t *handle, uint32_t addr, uint8_t page_number, uint8_t data[32], as608_status_t *status)
write notepad
Definition: driver_as608.c:2558
as608_bool_t
as608_bool_t
as608 bool enumeration definition
Definition: driver_as608.h:63
as608_get_valid_template_number
uint8_t as608_get_valid_template_number(as608_handle_t *handle, uint32_t addr, uint16_t *num, as608_status_t *status)
get valid template number
Definition: driver_as608.c:2972
as608_search_feature
uint8_t as608_search_feature(as608_handle_t *handle, uint32_t addr, as608_buffer_number_t num, uint16_t start_page, uint16_t page_number, uint16_t *found_page, uint16_t *score, as608_status_t *status)
search feature
Definition: driver_as608.c:836
as608_get_image
uint8_t as608_get_image(as608_handle_t *handle, uint32_t addr, as608_status_t *status)
get image
Definition: driver_as608.c:638
as608_download_feature
uint8_t as608_download_feature(as608_handle_t *handle, uint32_t addr, as608_buffer_number_t num, uint8_t *input_buffer, uint16_t input_len, as608_status_t *status)
download feature
Definition: driver_as608.c:1220
as608_get_last_status
uint8_t as608_get_last_status(as608_handle_t *handle, as608_status_t *status)
get the last status
Definition: driver_as608.c:607
as608_gpio_level_t
as608_gpio_level_t
as608 gpio level enumeration definition
Definition: driver_as608.h:144
as608_combine_feature
uint8_t as608_combine_feature(as608_handle_t *handle, uint32_t addr, as608_status_t *status)
combine feature
Definition: driver_as608.c:908
as608_print_status
uint8_t as608_print_status(as608_handle_t *handle, as608_status_t status)
print status
Definition: driver_as608.c:3176
as608_buffer_number_t
as608_buffer_number_t
as608 buffer number enumeration definition
Definition: driver_as608.h:95
as608_gpio_number_t
as608_gpio_number_t
as608 gpio number enumeration definition
Definition: driver_as608.h:135
as608_match_feature
uint8_t as608_match_feature(as608_handle_t *handle, uint32_t addr, uint16_t *score, as608_status_t *status)
match feature
Definition: driver_as608.c:767
as608_get_params
uint8_t as608_get_params(as608_handle_t *handle, uint32_t addr, as608_params_t *param, as608_status_t *status)
get params
Definition: driver_as608.c:1904
as608_set_level
uint8_t as608_set_level(as608_handle_t *handle, uint32_t addr, as608_level_t level, as608_status_t *status)
set level
Definition: driver_as608.c:1770
as608_delete_feature
uint8_t as608_delete_feature(as608_handle_t *handle, uint32_t addr, uint16_t page_number, uint16_t number, as608_status_t *status)
delete feature
Definition: driver_as608.c:1573
as608_set_baud_rate
uint8_t as608_set_baud_rate(as608_handle_t *handle, uint32_t addr, uint8_t n_9600, as608_status_t *status)
set baud rate
Definition: driver_as608.c:1704
as608_upload_feature
uint8_t as608_upload_feature(as608_handle_t *handle, uint32_t addr, as608_buffer_number_t num, uint8_t *output_buffer, uint16_t *output_len, as608_status_t *status)
upload feature
Definition: driver_as608.c:1113
as608_deinit
uint8_t as608_deinit(as608_handle_t *handle)
close the chip
Definition: driver_as608.c:575
as608_identify
uint8_t as608_identify(as608_handle_t *handle, uint32_t addr, uint16_t *page_number, uint16_t *score, as608_status_t *status)
identify
Definition: driver_as608.c:2047
as608_burn_code_mode_t
as608_burn_code_mode_t
as608 burn code mode enumeration definition
Definition: driver_as608.h:116
as608_set_chip_address
uint8_t as608_set_chip_address(as608_handle_t *handle, uint32_t addr, uint32_t new_addr, as608_status_t *status)
set the chip address
Definition: driver_as608.c:2317
as608_burn_code
uint8_t as608_burn_code(as608_handle_t *handle, uint32_t addr, as608_burn_code_mode_t mode, uint8_t *input_buffer, uint16_t input_len, as608_status_t *status)
burn code
Definition: driver_as608.c:2706
as608_read_notepad
uint8_t as608_read_notepad(as608_handle_t *handle, uint32_t addr, uint8_t page_number, uint8_t data[32], as608_status_t *status)
read notepad
Definition: driver_as608.c:2632
as608_packet_size_t
as608_packet_size_t
as608 packet size enumeration definition
Definition: driver_as608.h:84
as608_empty_all_feature
uint8_t as608_empty_all_feature(as608_handle_t *handle, uint32_t addr, as608_status_t *status)
empty all feature
Definition: driver_as608.c:1640
as608_image_t
as608_image_t
as608 image enumeration definition
Definition: driver_as608.h:125
as608_level_t
as608_level_t
as608 level enumeration definition
Definition: driver_as608.h:72
as608_set_gpio_level
uint8_t as608_set_gpio_level(as608_handle_t *handle, uint32_t addr, as608_gpio_number_t gpio, as608_gpio_level_t input_level, as608_gpio_level_t *output_level, as608_status_t *status)
set gpio level
Definition: driver_as608.c:3039
as608_generate_bin_image
uint8_t as608_generate_bin_image(as608_handle_t *handle, uint32_t addr, as608_image_t image, as608_status_t *status)
generate bin image
Definition: driver_as608.c:2907
as608_verify_password
uint8_t as608_verify_password(as608_handle_t *handle, uint32_t addr, uint32_t password, as608_status_t *status)
verify password
Definition: driver_as608.c:2181
as608_enroll
uint8_t as608_enroll(as608_handle_t *handle, uint32_t addr, uint16_t *page_number, as608_status_t *status)
enroll
Definition: driver_as608.c:1981
as608_high_speed_search
uint8_t as608_high_speed_search(as608_handle_t *handle, uint32_t addr, as608_buffer_number_t buffer_number, uint16_t start_page, uint16_t page_number, uint16_t *found_page, uint16_t *score, as608_status_t *status)
high speed search
Definition: driver_as608.c:2833
as608_get_flash_information
uint8_t as608_get_flash_information(as608_handle_t *handle, uint32_t addr, uint8_t *output_buffer, uint16_t *output_len, as608_status_t *status)
get flash information
Definition: driver_as608.c:2387
AS608_STATUS_FEATURE_COMBINE_ERROR
@ AS608_STATUS_FEATURE_COMBINE_ERROR
Definition: driver_as608.h:164
AS608_STATUS_OK
@ AS608_STATUS_OK
Definition: driver_as608.h:154
AS608_STATUS_UPDATE_ERROR
@ AS608_STATUS_UPDATE_ERROR
Definition: driver_as608.h:176
AS608_STATUS_DATA_INVALID
@ AS608_STATUS_DATA_INVALID
Definition: driver_as608.h:188
AS608_STATUS_BUFFER_INVALID
@ AS608_STATUS_BUFFER_INVALID
Definition: driver_as608.h:175
AS608_STATUS_NOT_FOUND
@ AS608_STATUS_NOT_FOUND
Definition: driver_as608.h:163
AS608_STATUS_F0_RESPONSE
@ AS608_STATUS_F0_RESPONSE
Definition: driver_as608.h:179
AS608_STATUS_FRAME_ERROR
@ AS608_STATUS_FRAME_ERROR
Definition: driver_as608.h:155
AS608_STATUS_NOT_MATCH
@ AS608_STATUS_NOT_MATCH
Definition: driver_as608.h:162
AS608_STATUS_F1_RESPONSE
@ AS608_STATUS_F1_RESPONSE
Definition: driver_as608.h:180
AS608_STATUS_LIB_CLEAR_ERROR
@ AS608_STATUS_LIB_CLEAR_ERROR
Definition: driver_as608.h:171
AS608_STATUS_NO_FRAME
@ AS608_STATUS_NO_FRAME
Definition: driver_as608.h:168
AS608_STATUS_INPUT_ERROR
@ AS608_STATUS_INPUT_ERROR
Definition: driver_as608.h:157
AS608_STATUS_FLASH_WRITE_SUM_ERROR
@ AS608_STATUS_FLASH_WRITE_SUM_ERROR
Definition: driver_as608.h:181
AS608_STATUS_PORT_INVALID
@ AS608_STATUS_PORT_INVALID
Definition: driver_as608.h:190
AS608_STATUS_IMAGE_TOO_CLUTTER
@ AS608_STATUS_IMAGE_TOO_CLUTTER
Definition: driver_as608.h:160
AS608_STATUS_IMAGE_TOO_WET
@ AS608_STATUS_IMAGE_TOO_WET
Definition: driver_as608.h:159
AS608_STATUS_IMAGE_TOO_FEW_FEATURE
@ AS608_STATUS_IMAGE_TOO_FEW_FEATURE
Definition: driver_as608.h:161
AS608_STATUS_REG_INVALID
@ AS608_STATUS_REG_INVALID
Definition: driver_as608.h:187
AS608_STATUS_FLASH_WRITE_ERROR
@ AS608_STATUS_FLASH_WRITE_ERROR
Definition: driver_as608.h:185
AS608_STATUS_NO_FINGERPRINT
@ AS608_STATUS_NO_FINGERPRINT
Definition: driver_as608.h:156
AS608_STATUS_UNKNOWN
@ AS608_STATUS_UNKNOWN
Definition: driver_as608.h:186
AS608_STATUS_FLASH_ERROR
@ AS608_STATUS_FLASH_ERROR
Definition: driver_as608.h:178
AS608_STATUS_LIB_DELETE_ERROR
@ AS608_STATUS_LIB_DELETE_ERROR
Definition: driver_as608.h:170
AS608_STATUS_ENROOL_ERROR
@ AS608_STATUS_ENROOL_ERROR
Definition: driver_as608.h:191
AS608_STATUS_FLASH_WRITE_LENGTH_TOO_LONG
@ AS608_STATUS_FLASH_WRITE_LENGTH_TOO_LONG
Definition: driver_as608.h:184
AS608_STATUS_COMMAND_INVALID
@ AS608_STATUS_COMMAND_INVALID
Definition: driver_as608.h:173
AS608_STATUS_LIB_ADDR_OVER
@ AS608_STATUS_LIB_ADDR_OVER
Definition: driver_as608.h:165
AS608_STATUS_NO_MOVE
@ AS608_STATUS_NO_MOVE
Definition: driver_as608.h:177
AS608_STATUS_ENTER_LOW_POWER_ERROR
@ AS608_STATUS_ENTER_LOW_POWER_ERROR
Definition: driver_as608.h:172
AS608_STATUS_RESET_ERROR
@ AS608_STATUS_RESET_ERROR
Definition: driver_as608.h:174
AS608_STATUS_NOTE_PAGE_INVALID
@ AS608_STATUS_NOTE_PAGE_INVALID
Definition: driver_as608.h:189
AS608_STATUS_UPLOAD_FEATURE_ERROR
@ AS608_STATUS_UPLOAD_FEATURE_ERROR
Definition: driver_as608.h:167
AS608_STATUS_FLASH_WRITE_HEADER_ERROR
@ AS608_STATUS_FLASH_WRITE_HEADER_ERROR
Definition: driver_as608.h:182
AS608_STATUS_FLASH_WRITE_LENGTH_ERROR
@ AS608_STATUS_FLASH_WRITE_LENGTH_ERROR
Definition: driver_as608.h:183
AS608_STATUS_UPLOAD_IMAGE_ERROR
@ AS608_STATUS_UPLOAD_IMAGE_ERROR
Definition: driver_as608.h:169
AS608_STATUS_LIB_READ_ERROR
@ AS608_STATUS_LIB_READ_ERROR
Definition: driver_as608.h:166
AS608_STATUS_IMAGE_TOO_DRY
@ AS608_STATUS_IMAGE_TOO_DRY
Definition: driver_as608.h:158
AS608_STATUS_LIB_FULL
@ AS608_STATUS_LIB_FULL
Definition: driver_as608.h:192
AS608_BOOL_FALSE
@ AS608_BOOL_FALSE
Definition: driver_as608.h:64
AS608_BOOL_TRUE
@ AS608_BOOL_TRUE
Definition: driver_as608.h:65
as608_command_write_read
uint8_t as608_command_write_read(as608_handle_t *handle, uint32_t addr, uint8_t type, uint8_t *input_buffer, uint16_t input_len, uint16_t ms, uint8_t *output_buffer, uint16_t *output_len)
write read data to chip
Definition: driver_as608.c:3453
as608_handle_s
as608 handle structure definition
Definition: driver_as608.h:213
as608_handle_s::uart_flush
uint8_t(* uart_flush)(void)
Definition: driver_as608.h:217
as608_handle_s::inited
uint8_t inited
Definition: driver_as608.h:221
as608_handle_s::uart_write
uint8_t(* uart_write)(uint8_t *buf, uint16_t len)
Definition: driver_as608.h:218
as608_handle_s::delay_ms
void(* delay_ms)(uint32_t ms)
Definition: driver_as608.h:219
as608_handle_s::uart_deinit
uint8_t(* uart_deinit)(void)
Definition: driver_as608.h:215
as608_handle_s::debug_print
void(* debug_print)(const char *const fmt,...)
Definition: driver_as608.h:220
as608_handle_s::uart_read
uint16_t(* uart_read)(uint8_t *buf, uint16_t len)
Definition: driver_as608.h:216
as608_handle_s::packet_size
uint16_t packet_size
Definition: driver_as608.h:224
as608_handle_s::uart_init
uint8_t(* uart_init)(void)
Definition: driver_as608.h:214
as608_handle_s::status
uint8_t status
Definition: driver_as608.h:223
as608_handle_s::buf
uint8_t buf[384]
Definition: driver_as608.h:222
as608_info_s
as608 information structure definition
Definition: driver_as608.h:231
as608_info_s::temperature_max
float temperature_max
Definition: driver_as608.h:239
as608_info_s::supply_voltage_max_v
float supply_voltage_max_v
Definition: driver_as608.h:236
as608_info_s::driver_version
uint32_t driver_version
Definition: driver_as608.h:240
as608_info_s::temperature_min
float temperature_min
Definition: driver_as608.h:238
as608_info_s::max_current_ma
float max_current_ma
Definition: driver_as608.h:237
as608_info_s::manufacturer_name
char manufacturer_name[32]
Definition: driver_as608.h:233
as608_info_s::supply_voltage_min_v
float supply_voltage_min_v
Definition: driver_as608.h:235
as608_info_s::interface
char interface[8]
Definition: driver_as608.h:234
as608_info_s::chip_name
char chip_name[32]
Definition: driver_as608.h:232
as608_params_s
as608 params structure definition
Definition: driver_as608.h:199
as608_params_s::status
uint16_t status
Definition: driver_as608.h:200
as608_params_s::level
as608_level_t level
Definition: driver_as608.h:203
as608_params_s::sensor_type
as608_sensor_type_t sensor_type
Definition: driver_as608.h:201
as608_params_s::address
uint32_t address
Definition: driver_as608.h:204
as608_params_s::n_9600
uint16_t n_9600
Definition: driver_as608.h:206
as608_params_s::fingerprint_size
uint16_t fingerprint_size
Definition: driver_as608.h:202
as608_params_s::packet_size
as608_packet_size_t packet_size
Definition: driver_as608.h:205