finger.cpp 4.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235
  1. /*
  2. Description: FINGER UNIT use case: Press the left button to enter the fingerprint entry mode. Press the middle button to enter the fingerprint identification mode.
  3. */
  4. #include <M5Stack.h>
  5. #include "finger.h"
  6. FingerPrint::FingerPrint(void){
  7. }
  8. FingerPrint FP;
  9. #define F_Time 10000
  10. uint8_t FingerPrint::fpm_sendAndReceive(uint16_t timeout)
  11. {
  12. uint8_t i, j;
  13. uint8_t checkSum = 0;
  14. FP.RxCnt = 0;
  15. FP.TxBuf[5] = 0;
  16. Serial2.write(CMD_HEAD);
  17. for (i = 1; i < 6; i++)
  18. {
  19. Serial2.write(FP.TxBuf[i]);
  20. checkSum ^= FP.TxBuf[i];
  21. }
  22. Serial2.write(checkSum);
  23. Serial2.write(CMD_TAIL);
  24. while ((!Serial2.available()) && timeout > 0)
  25. {
  26. delay(1);
  27. timeout--;
  28. }
  29. uint8_t ch;
  30. for(i=0;i<8;i++)
  31. {
  32. if(Serial2.available()){
  33. ch = Serial2.read();
  34. FP.RxCnt++;
  35. FP.RxBuf[i] = ch;
  36. }
  37. }
  38. if (FP.RxCnt != 8) {FP.RxCnt = 0;return ACK_TIMEOUT;}
  39. if (FP.RxBuf[HEAD] != CMD_HEAD) return ACK_FAIL;
  40. if (FP.RxBuf[TAIL] != CMD_TAIL) return ACK_FAIL;
  41. if (FP.RxBuf[CMD] != (FP.TxBuf[CMD])) return ACK_FAIL;
  42. checkSum = 0;
  43. for (j = 1; j < CHK; j++) {
  44. checkSum ^= FP.RxBuf[j];
  45. }
  46. if (checkSum != FP.RxBuf[CHK]) {
  47. return ACK_FAIL;
  48. }
  49. return ACK_SUCCESS;
  50. }
  51. uint8_t FingerPrint::fpm_sleep(void)
  52. {
  53. uint8_t res;
  54. FP.TxBuf[CMD] = CMD_SLEEP_MODE;
  55. FP.TxBuf[P1] = 0;
  56. FP.TxBuf[P2] = 0;
  57. FP.TxBuf[P3] = 0;
  58. res = fpm_sendAndReceive(500);
  59. if(res == ACK_SUCCESS) {
  60. return ACK_SUCCESS;
  61. }
  62. else {
  63. return ACK_FAIL;
  64. }
  65. }
  66. uint8_t FingerPrint::fpm_setAddMode(uint8_t fpm_mode)
  67. {
  68. uint8_t res;
  69. FP.TxBuf[CMD] = CMD_ADD_MODE;
  70. FP.TxBuf[P1] = 0;
  71. FP.TxBuf[P2] = fpm_mode;
  72. FP.TxBuf[P3] = 0;
  73. res = fpm_sendAndReceive(200);
  74. if(res == ACK_SUCCESS && RxBuf[Q3] == ACK_SUCCESS) {
  75. return ACK_SUCCESS;
  76. }
  77. else {
  78. return ACK_FAIL;
  79. }
  80. }
  81. uint8_t FingerPrint::fpm_readAddMode(void)
  82. {
  83. FP.TxBuf[CMD] = CMD_ADD_MODE;
  84. FP.TxBuf[P1] = 0;
  85. FP.TxBuf[P2] = 0;
  86. FP.TxBuf[P3] = 0X01;
  87. fpm_sendAndReceive(200);
  88. return RxBuf[Q2];
  89. }
  90. uint16_t FingerPrint::fpm_getUserNum(void)
  91. {
  92. uint8_t res;
  93. FP.TxBuf[CMD] = CMD_USER_CNT;
  94. FP.TxBuf[P1] = 0;
  95. FP.TxBuf[P2] = 0;
  96. FP.TxBuf[P3] = 0;
  97. res = fpm_sendAndReceive(200);
  98. if(res == ACK_SUCCESS && FP.RxBuf[Q3] == ACK_SUCCESS) {
  99. return FP.RxBuf[Q2];
  100. }
  101. else {
  102. return 0XFF;
  103. }
  104. }
  105. uint8_t FingerPrint::fpm_deleteAllUser(void)
  106. {
  107. uint8_t res;
  108. FP.TxBuf[CMD] = CMD_DEL_ALL;
  109. FP.TxBuf[P1] = 0;
  110. FP.TxBuf[P2] = 0;
  111. FP.TxBuf[P3] = 0;
  112. res = fpm_sendAndReceive(200);
  113. if(res == ACK_SUCCESS && RxBuf[Q3] == ACK_SUCCESS) {
  114. return ACK_SUCCESS;
  115. }
  116. else {
  117. return ACK_FAIL;
  118. }
  119. }
  120. uint8_t FingerPrint::fpm_deleteUser(uint8_t userNum)
  121. {
  122. uint8_t res;
  123. FP.TxBuf[CMD] = CMD_DEL;
  124. FP.TxBuf[P1] = 0;
  125. FP.TxBuf[P2] = userNum;
  126. FP.TxBuf[P3] = 0;
  127. res = fpm_sendAndReceive(200);
  128. if(res == ACK_SUCCESS && RxBuf[Q3] == ACK_SUCCESS) {
  129. return ACK_SUCCESS;
  130. }
  131. else {
  132. return ACK_FAIL;
  133. }
  134. }
  135. uint8_t FingerPrint::fpm_addUser(uint8_t userNum, uint8_t userPermission)
  136. {
  137. uint8_t res;
  138. FP.TxBuf[CMD] = CMD_ADD_1;
  139. FP.TxBuf[P1] = 0;
  140. FP.TxBuf[P2] = userNum;
  141. FP.TxBuf[P3] = userPermission;
  142. res = fpm_sendAndReceive(F_Time);
  143. if(res == ACK_SUCCESS) {
  144. if(FP.RxBuf[Q3] == ACK_SUCCESS) {
  145. FP.TxBuf[CMD] = CMD_ADD_2;
  146. res = fpm_sendAndReceive(F_Time);
  147. if(res == ACK_SUCCESS) {
  148. if(FP.RxBuf[Q3] == ACK_SUCCESS) {
  149. FP.TxBuf[CMD] = CMD_ADD_3;
  150. res = fpm_sendAndReceive(F_Time);
  151. if(res == ACK_SUCCESS) {
  152. return FP.RxBuf[Q3];
  153. }
  154. }
  155. }
  156. }
  157. }
  158. return res;
  159. }
  160. uint8_t FingerPrint::fpm_compareFinger(void)
  161. {
  162. uint8_t res;
  163. FP.TxBuf[CMD] = CMD_MATCH;
  164. FP.TxBuf[P1] = 0;
  165. FP.TxBuf[P2] = 0;
  166. FP.TxBuf[P3] = 0;
  167. res = fpm_sendAndReceive(8000);
  168. if(res == ACK_SUCCESS)
  169. {
  170. if(FP.RxBuf[Q3] == ACK_NOUSER) {
  171. return ACK_NOUSER;
  172. }
  173. if(FP.RxBuf[Q3] == ACK_TIMEOUT) {
  174. return ACK_TIMEOUT;
  175. }
  176. if((FP.RxBuf[Q2] != 0) && (FP.RxBuf[Q3] == 1 || FP.RxBuf[Q3] == 2 || FP.RxBuf[Q3] == 3)) {
  177. return ACK_SUCCESS;
  178. }
  179. }
  180. return res;
  181. }