grove_fingerprint.cpp

00001 
00002 
00003 #include "suli2.h"
00004 #include "grove_fingerprint.h"
00005 
00006 //local functions
00007 static void grove_fingerprint_writePacket(UART_T *uart, uint32_t addr, uint8_t packettype, 
00008                        uint16_t len, uint8_t *packet);
00009 static uint8_t grove_fingerprint_getReply(UART_T *uart, uint8_t packet[], uint16_t timeout);
00010 
00011 //local variables
00012 static uint32_t thePassword;
00013 static uint32_t theAddress;
00014 static uint16_t fingerID, confidence, templateCount;
00015 static unsigned char cmd[CMD_LENGTH];
00016 
00017 
00018 
00019 void grove_fingerprint_init(UART_T *uart, int pintx, int pinrx)
00020 {
00021     suli_uart_init(uart, pintx, pinrx, 57600);
00022 }
00023 
00024 bool grove_fingerprint_write_setup(UART_T *uart)
00025 {
00026     thePassword = 0;
00027     theAddress = 0xFFFFFFFF;
00028     
00029     return true;
00030 }
00031 
00032 bool grove_fingerprint_verifyPassword(UART_T *uart) {
00033   uint8_t packet[20] = {FINGERPRINT_VERIFYPASSWORD, 
00034                       (thePassword >> 24), (thePassword >> 16),
00035                       (thePassword >> 8), thePassword};
00036   grove_fingerprint_writePacket(uart, theAddress, FINGERPRINT_COMMANDPACKET, 5+2, packet);
00037   uint8_t len = grove_fingerprint_getReply(uart, packet, 500);
00038   
00039   if ((len == 1) && (packet[0] == FINGERPRINT_ACKPACKET) && (packet[1] == FINGERPRINT_OK))
00040     return true;
00041 
00042 /*
00043   Serial.print("\nGot packet type "); Serial.print(packet[0]);
00044   for (uint8_t i=1; i<len+1;i++) {
00045     Serial.print(" 0x");
00046     Serial.print(packet[i], HEX);
00047   }
00048   */
00049   return false;
00050 }
00051 
00052 bool grove_fingerprint_getImage(UART_T *uart, uint8_t *res) {
00053   uint8_t packet[20] = {FINGERPRINT_GETIMAGE};
00054   grove_fingerprint_writePacket(uart, theAddress, FINGERPRINT_COMMANDPACKET, 1+2, packet);
00055   uint8_t len = grove_fingerprint_getReply(uart, packet, 500);
00056   
00057   if ((len != 1) && (packet[0] != FINGERPRINT_ACKPACKET))
00058    return false;
00059    else
00060    {
00061     *res = packet[1];
00062     return true;
00063    }
00064 }
00065 
00066 bool grove_fingerprint_image2Tz(UART_T *uart, uint8_t slot, uint8_t *res) {
00067   uint8_t packet[20] = {FINGERPRINT_IMAGE2TZ, slot};
00068   grove_fingerprint_writePacket(uart, theAddress, FINGERPRINT_COMMANDPACKET, 2+2, packet);
00069   uint8_t len = grove_fingerprint_getReply(uart, packet, 500);
00070   
00071   if ((len != 1) && (packet[0] != FINGERPRINT_ACKPACKET))
00072    return false;
00073    else
00074    {
00075     *res = packet[1];
00076     return true;
00077    }
00078 }
00079 
00080 bool grove_fingerprint_createModel(UART_T *uart, uint8_t *res) {
00081   uint8_t packet[20] = {FINGERPRINT_REGMODEL};
00082   grove_fingerprint_writePacket(uart, theAddress, FINGERPRINT_COMMANDPACKET, 1+2, packet);
00083   uint8_t len = grove_fingerprint_getReply(uart, packet, 500);
00084   
00085   if ((len != 1) && (packet[0] != FINGERPRINT_ACKPACKET))
00086    return false;
00087    else
00088    {
00089     *res = packet[1];
00090     return true;
00091    }
00092 }
00093 
00094 
00095 bool grove_fingerprint_storeModel(UART_T *uart, uint16_t id, uint8_t *res) {
00096   uint8_t packet[20] = {FINGERPRINT_STORE, 0x01, id >> 8, id & 0xFF};
00097   grove_fingerprint_writePacket(uart, theAddress, FINGERPRINT_COMMANDPACKET, 4+2, packet);
00098   uint8_t len = grove_fingerprint_getReply(uart, packet, 500);
00099   
00100   if ((len != 1) && (packet[0] != FINGERPRINT_ACKPACKET))
00101    return false;
00102    else
00103    {
00104     *res = packet[1];
00105     return true;
00106    }
00107 }
00108 
00109 bool grove_fingerprint_deleteModel(UART_T *uart, uint16_t id, uint8_t *res) {
00110     uint8_t packet[20] = {FINGERPRINT_DELETE, id >> 8, id & 0xFF, 0x00, 0x01};
00111     grove_fingerprint_writePacket(uart, theAddress, FINGERPRINT_COMMANDPACKET, 5+2, packet);
00112     uint8_t len = grove_fingerprint_getReply(uart, packet, 500);
00113         
00114    if ((len != 1) && (packet[0] != FINGERPRINT_ACKPACKET))
00115    return false;
00116    else
00117    {
00118     *res = packet[1];
00119     return true;
00120    }
00121 }
00122 
00123 bool grove_fingerprint_emptyDatabase(UART_T *uart, uint8_t *res) {
00124   uint8_t packet[20] = {FINGERPRINT_EMPTY};
00125   grove_fingerprint_writePacket(uart, theAddress, FINGERPRINT_COMMANDPACKET, 1+2, packet);
00126   uint8_t len = grove_fingerprint_getReply(uart, packet, 500);
00127   
00128   if ((len != 1) && (packet[0] != FINGERPRINT_ACKPACKET))
00129    return false;
00130    else
00131    {
00132     *res = packet[1];
00133     return true;
00134    }
00135 }
00136 
00137 bool grove_fingerprint_fingerFastSearch(UART_T *uart, uint8_t *res) {
00138   fingerID = 0xFFFF;
00139   confidence = 0xFFFF;
00140   // high speed search of slot #1 starting at page 0x0000 and page #0x00A3 
00141   uint8_t packet[20] = {FINGERPRINT_HISPEEDSEARCH, 0x01, 0x00, 0x00, 0x00, 0xA3};
00142   grove_fingerprint_writePacket(uart, theAddress, FINGERPRINT_COMMANDPACKET, 6+2, packet);
00143   uint8_t len = grove_fingerprint_getReply(uart, packet, 500);
00144   
00145   if ((len != 1) && (packet[0] != FINGERPRINT_ACKPACKET))
00146    return false;
00147 
00148   fingerID = packet[2];
00149   fingerID <<= 8;
00150   fingerID |= packet[3];
00151   
00152   confidence = packet[4];
00153   confidence <<= 8;
00154   confidence |= packet[5];
00155   
00156   *res = packet[1];
00157     return true;
00158 }
00159 
00160 bool grove_fingerprint_getTemplateCount(UART_T *uart, uint8_t *res) {
00161   templateCount = 0xFFFF;
00162   // get number of templates in memory
00163   uint8_t packet[20] = {FINGERPRINT_TEMPLATECOUNT};
00164   grove_fingerprint_writePacket(uart, theAddress, FINGERPRINT_COMMANDPACKET, 1+2, packet);
00165   uint8_t len = grove_fingerprint_getReply(uart, packet, 500);
00166   
00167   if ((len != 1) && (packet[0] != FINGERPRINT_ACKPACKET))
00168    return false;
00169 
00170   templateCount = packet[2];
00171   templateCount <<= 8;
00172   templateCount |= packet[3];
00173   
00174   *res = packet[1];
00175     return true;
00176 }
00177 
00178 static void grove_fingerprint_writePacket(UART_T *uart, uint32_t addr, uint8_t packettype, 
00179                        uint16_t len, uint8_t *packet) {
00180     uint8_t i = 0;
00181  
00182 
00183     cmd[0] = (uint8_t)(FINGERPRINT_STARTCODE >> 8);
00184     cmd[1] = (uint8_t)FINGERPRINT_STARTCODE;
00185     cmd[2] = (uint8_t)(addr >> 24);
00186     cmd[3] = (uint8_t)(addr >> 16);
00187     cmd[4] = (uint8_t)(addr >> 8);
00188     cmd[5] = (uint8_t)(addr);
00189     cmd[6] = (uint8_t)packettype;
00190     cmd[7] = (uint8_t)(len >> 8);
00191     cmd[8] = (uint8_t)(len);
00192 
00193   uint16_t sum = (len>>8) + (len&0xFF) + packettype;
00194   for (i=0; i< len-2; i++) {
00195     cmd[9+i] = packet[i];
00196     sum += packet[i];
00197   }
00198 
00199     cmd[9+i] = (uint8_t)(sum>>8);
00200     cmd[9+i+1] = (uint8_t)sum;
00201     
00202     suli_uart_write_bytes(uart, (uint8_t*)cmd, 9+i+1+1);
00203 }
00204 
00205 
00206 static uint8_t grove_fingerprint_getReply(UART_T *uart, uint8_t packet[], uint16_t timeout) {
00207   uint8_t reply[20], idx;
00208   uint16_t timer=0;
00209   
00210   idx = 0;
00211 #ifdef FINGERPRINT_DEBUG
00212   Serial.print("<--- ");
00213 #endif
00214 while (true) {
00215     while (!suli_uart_readable(uart))
00216     {
00217       suli_delay_ms(1);
00218       timer++;
00219       if (timer >= timeout) return FINGERPRINT_TIMEOUT;
00220     }
00221     
00222     reply[idx] = suli_uart_read(uart);
00223 
00224     if ((idx == 0) && (reply[0] != (FINGERPRINT_STARTCODE >> 8)))
00225       continue;
00226     idx++;
00227     
00228     // check packet!
00229     if (idx >= 9) {
00230       if ((reply[0] != (FINGERPRINT_STARTCODE >> 8)) ||
00231           (reply[1] != (FINGERPRINT_STARTCODE & 0xFF)))
00232           return FINGERPRINT_BADPACKET;
00233       uint8_t packettype = reply[6];
00234       
00235       uint16_t len = reply[7];
00236       len <<= 8;
00237       len |= reply[8];
00238       len -= 2;
00239       
00240       if (idx <= (len+10)) continue;
00241       packet[0] = packettype;      
00242       for (uint8_t i=0; i<len; i++) {
00243         packet[1+i] = reply[9+i];
00244       }
00245 
00246       return len;
00247     }
00248   }
00249 }
00250 
00251 
00252 
00253 
00254 
00255 
00256 
00257 
00258