for R503 fingerprint
Dependents: R503_fingerprint_HelloWorld
Revision 0:35cd316e4b41, committed 2021-03-16
- Comitter:
- cdupaty
- Date:
- Tue Mar 16 16:31:41 2021 +0000
- Commit message:
- Version 0.1 with a lot of bugs
Changed in this revision
Fingerprint.cpp | Show annotated file Show diff for this revision Revisions of this file |
Fingerprint.h | Show annotated file Show diff for this revision Revisions of this file |
diff -r 000000000000 -r 35cd316e4b41 Fingerprint.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Fingerprint.cpp Tue Mar 16 16:31:41 2021 +0000 @@ -0,0 +1,519 @@ +/*! + * @file Fingerprint.cpp + * + * @mainpage Adafruit Fingerprint Sensor Library + * + * @section intro_sec Introduction + * + * This is a library for our optical Fingerprint sensor + * + * Designed specifically to work with the Adafruit Fingerprint sensor + * ---. http://www.adafruit.com/products/751 + * + * These displays use TTL Serial to communicate, 2 pins are required to + * interface + * Adafruit invests time and resources providing this open source code, + * please support Adafruit and open-source hardware by purchasing + * products from Adafruit! + * + * @section author Author + * + * Written by Limor Fried/Ladyada for Adafruit Industries. + * + * @section license License + * + * BSD license, all text above must be included in any redistribution + * + */ + +#include "Fingerprint.h" + +//#define FINGERPRINT_DEBUG + +/*! + * @brief Gets the command packet + */ +#define GET_CMD_PACKET(...) \ +uint8_t data[] = {__VA_ARGS__}; \ + Fingerprint_Packet packet(FINGERPRINT_COMMANDPACKET, sizeof(data),data); \ + writeStructuredPacket(packet); \ + if (getStructuredPacket(&packet) != FINGERPRINT_OK) \ + return FINGERPRINT_PACKETRECIEVEERR; \ + if (packet->type != FINGERPRINT_ACKPACKET) \ + return FINGERPRINT_PACKETRECIEVEERR; + +/*! + * @brief Sends the command packet + */ +#define SEND_CMD_PACKET(...) \ + GET_CMD_PACKET(__VA_ARGS__); \ + return packet->data[0]; + +/*************************************************************************** + PUBLIC FUNCTIONS + ***************************************************************************/ + + +/**************************************************************************/ +/*! + @brief Instantiates sensor with Software Serial + @param ss Pointer to SoftwareSerial object + @param password 32-bit integer password (default is 0) +*/ +/**************************************************************************/ +Fingerprint::Fingerprint(PinName serialTX, PinName serialRX, PinName reset, uint32_t password) : + R503Serial(serialTX, serialRX), _reset(reset) +{ + thePassword = password; + theAddress = 0xFFFFFFFF; + + status_reg = 0x0; ///< The status register (set by getParameters) + system_id = 0x0; ///< The system identifier (set by getParameters) + capacity = 64; ///< The fingerprint capacity (set by getParameters) + security_level = 0; ///< The security level (set by getParameters) + device_addr = 0xFFFFFFFF; ///< The device address (set by getParameters) + packet_len = 64; ///< The max packet length (set by getParameters) + baud_rate = 57600; ///< The UART baud rate (set by getParameters) + +} + + + +/**************************************************************************/ +/*! + @brief Initializes serial interface and baud rate + @param baudrate Sensor's UART baud rate (usually 57600, 9600 or 115200) +*/ +/**************************************************************************/ +void Fingerprint::begin(uint32_t baudrate) { + R503Serial.baud(baudrate); +} + +/**************************************************************************/ +/*! + @brief Verifies the sensors' access password (default password is + 0x0000000). A good way to also check if the sensors is active and responding + @returns True if password is correct +*/ +/**************************************************************************/ +bool Fingerprint::verifyPassword(void) { + return checkPassword() == FINGERPRINT_OK; +} + +uint8_t Fingerprint::checkPassword(void) { + GET_CMD_PACKET(FINGERPRINT_VERIFYPASSWORD, (uint8_t)(thePassword >> 24),(uint8_t)(thePassword >> 16), (uint8_t)(thePassword >> 8),(uint8_t)(thePassword & 0xFF)); + if (packet->data[0] == FINGERPRINT_OK) + return FINGERPRINT_OK; + else + return FINGERPRINT_PACKETRECIEVEERR; +} + +/**************************************************************************/ +/*! + @brief Get the sensors parameters, fills in the member variables + status_reg, system_id, capacity, security_level, device_addr, packet_len + and baud_rate + @returns True if password is correct +*/ +/**************************************************************************/ +uint8_t Fingerprint::getParameters(void) { + GET_CMD_PACKET(FINGERPRINT_READSYSPARAM); + + status_reg = ((uint16_t)packet->data[1] << 8) | packet->data[2]; + system_id = ((uint16_t)packet->data[3] << 8) | packet->data[4]; + capacity = ((uint16_t)packet->data[5] << 8) | packet->data[6]; + security_level = ((uint16_t)packet->data[7] << 8) | packet->data[8]; + device_addr = ((uint32_t)packet->data[9] << 24) | + ((uint32_t)packet->data[10] << 16) | + ((uint32_t)packet->data[11] << 8) | (uint32_t)packet->data[12]; + packet_len = ((uint16_t)packet->data[13] << 8) | packet->data[14]; + if (packet_len == 0) { + packet_len = 32; + } else if (packet_len == 1) { + packet_len = 64; + } else if (packet_len == 2) { + packet_len = 128; + } else if (packet_len == 3) { + packet_len = 256; + } + baud_rate = (((uint16_t)packet->data[15] << 8) | packet->data[16]) * 9600; + + return packet->data[0]; +} + +/**************************************************************************/ +/*! + @brief Ask the sensor to take an image of the finger pressed on surface + @returns <code>FINGERPRINT_OK</code> on success + @returns <code>FINGERPRINT_NOFINGER</code> if no finger detected + @returns <code>FINGERPRINT_PACKETRECIEVEERR</code> on communication error + @returns <code>FINGERPRINT_IMAGEFAIL</code> on imaging error +*/ +/**************************************************************************/ +uint8_t Fingerprint::getImage(void) { + SEND_CMD_PACKET(FINGERPRINT_GETIMAGE); +} + +/**************************************************************************/ +/*! + @brief Ask the sensor to convert image to feature template + @param slot Location to place feature template (put one in 1 and another in + 2 for verification to create model) + @returns <code>FINGERPRINT_OK</code> on success + @returns <code>FINGERPRINT_IMAGEMESS</code> if image is too messy + @returns <code>FINGERPRINT_PACKETRECIEVEERR</code> on communication error + @returns <code>FINGERPRINT_FEATUREFAIL</code> on failure to identify + fingerprint features + @returns <code>FINGERPRINT_INVALIDIMAGE</code> on failure to identify + fingerprint features +*/ +uint8_t Fingerprint::image2Tz(uint8_t slot) { + SEND_CMD_PACKET(FINGERPRINT_IMAGE2TZ, slot); +} + +/**************************************************************************/ +/*! + @brief Ask the sensor to take two print feature template and create a + model + @returns <code>FINGERPRINT_OK</code> on success + @returns <code>FINGERPRINT_PACKETRECIEVEERR</code> on communication error + @returns <code>FINGERPRINT_ENROLLMISMATCH</code> on mismatch of fingerprints +*/ +uint8_t Fingerprint::createModel(void) { + SEND_CMD_PACKET(FINGERPRINT_REGMODEL); +} + +/**************************************************************************/ +/*! + @brief Ask the sensor to store the calculated model for later matching + @param location The model location # + @returns <code>FINGERPRINT_OK</code> on success + @returns <code>FINGERPRINT_BADLOCATION</code> if the location is invalid + @returns <code>FINGERPRINT_FLASHERR</code> if the model couldn't be written + to flash memory + @returns <code>FINGERPRINT_PACKETRECIEVEERR</code> on communication error +*/ +uint8_t Fingerprint::storeModel(uint16_t location) { + SEND_CMD_PACKET(FINGERPRINT_STORE, 0x01, (uint8_t)(location >> 8), + (uint8_t)(location & 0xFF)); +} + +/**************************************************************************/ +/*! + @brief Ask the sensor to load a fingerprint model from flash into buffer 1 + @param location The model location # + @returns <code>FINGERPRINT_OK</code> on success + @returns <code>FINGERPRINT_BADLOCATION</code> if the location is invalid + @returns <code>FINGERPRINT_PACKETRECIEVEERR</code> on communication error +*/ +uint8_t Fingerprint::loadModel(uint16_t location) { + SEND_CMD_PACKET(FINGERPRINT_LOAD, 0x01, (uint8_t)(location >> 8), + (uint8_t)(location & 0xFF)); +} + +/**************************************************************************/ +/*! + @brief Ask the sensor to transfer 256-byte fingerprint template from the + buffer to the UART + @returns <code>FINGERPRINT_OK</code> on success + @returns <code>FINGERPRINT_PACKETRECIEVEERR</code> on communication error +*/ +uint8_t Fingerprint::getModel(void) { + SEND_CMD_PACKET(FINGERPRINT_UPLOAD, 0x01); +} + +/**************************************************************************/ +/*! + @brief Ask the sensor to delete a model in memory + @param location The model location # + @returns <code>FINGERPRINT_OK</code> on success + @returns <code>FINGERPRINT_BADLOCATION</code> if the location is invalid + @returns <code>FINGERPRINT_FLASHERR</code> if the model couldn't be written + to flash memory + @returns <code>FINGERPRINT_PACKETRECIEVEERR</code> on communication error +*/ +uint8_t Fingerprint::deleteModel(uint16_t location) { + SEND_CMD_PACKET(FINGERPRINT_DELETE, (uint8_t)(location >> 8), + (uint8_t)(location & 0xFF), 0x00, 0x01); +} + +/**************************************************************************/ +/*! + @brief Ask the sensor to delete ALL models in memory + @returns <code>FINGERPRINT_OK</code> on success + @returns <code>FINGERPRINT_BADLOCATION</code> if the location is invalid + @returns <code>FINGERPRINT_FLASHERR</code> if the model couldn't be written + to flash memory + @returns <code>FINGERPRINT_PACKETRECIEVEERR</code> on communication error +*/ +uint8_t Fingerprint::emptyDatabase(void) { + SEND_CMD_PACKET(FINGERPRINT_EMPTY); +} + +/**************************************************************************/ +/*! + @brief Ask the sensor to search the current slot 1 fingerprint features to + match saved templates. The matching location is stored in <b>fingerID</b> and + the matching confidence in <b>confidence</b> + @returns <code>FINGERPRINT_OK</code> on fingerprint match success + @returns <code>FINGERPRINT_NOTFOUND</code> no match made + @returns <code>FINGERPRINT_PACKETRECIEVEERR</code> on communication error +*/ +/**************************************************************************/ +uint8_t Fingerprint::fingerFastSearch(void) { + // high speed search of slot #1 starting at page 0x0000 and page #0x00A3 + GET_CMD_PACKET(FINGERPRINT_HISPEEDSEARCH, 0x01, 0x00, 0x00, 0x00, 0xA3); + fingerID = 0xFFFF; + confidence = 0xFFFF; + + fingerID = packet->data[1]; + fingerID <<= 8; + fingerID |= packet->data[2]; + + confidence = packet->data[3]; + confidence <<= 8; + confidence |= packet->data[4]; + + return packet->data[0]; +} + +/**************************************************************************/ +/*! + @brief Control the built in LED + @param on True if you want LED on, False to turn LED off + @returns <code>FINGERPRINT_OK</code> on success +*/ +/**************************************************************************/ +uint8_t Fingerprint::LEDcontrol(bool on) { + if (on) { + SEND_CMD_PACKET(FINGERPRINT_LEDON); + } else { + SEND_CMD_PACKET(FINGERPRINT_LEDOFF); + } +} + +/**************************************************************************/ +/*! + @brief Control the built in Aura LED (if exists). Check datasheet/manual + for different colors and control codes available + @param control The control code (e.g. breathing, full on) + @param speed How fast to go through the breathing/blinking cycles + @param coloridx What color to light the indicator + @param count How many repeats of blinks/breathing cycles + @returns <code>FINGERPRINT_OK</code> on fingerprint match success + @returns <code>FINGERPRINT_NOTFOUND</code> no match made + @returns <code>FINGERPRINT_PACKETRECIEVEERR</code> on communication error +*/ +/**************************************************************************/ +uint8_t Fingerprint::LEDcontrol(uint8_t control, uint8_t speed, + uint8_t coloridx, uint8_t count) { + SEND_CMD_PACKET(FINGERPRINT_AURALEDCONFIG, control, speed, coloridx, count); +} + +/**************************************************************************/ +/*! + @brief Ask the sensor to search the current slot fingerprint features to + match saved templates. The matching location is stored in <b>fingerID</b> and + the matching confidence in <b>confidence</b> + @param slot The slot to use for the print search, defaults to 1 + @returns <code>FINGERPRINT_OK</code> on fingerprint match success + @returns <code>FINGERPRINT_NOTFOUND</code> no match made + @returns <code>FINGERPRINT_PACKETRECIEVEERR</code> on communication error +*/ +/**************************************************************************/ +uint8_t Fingerprint::fingerSearch(uint8_t slot) { + // search of slot starting thru the capacity + GET_CMD_PACKET(FINGERPRINT_SEARCH, slot, 0x00, 0x00, capacity >> 8, + capacity & 0xFF); + + fingerID = 0xFFFF; + confidence = 0xFFFF; + + fingerID = packet->data[1]; + fingerID <<= 8; + fingerID |= packet->data[2]; + + confidence = packet->data[3]; + confidence <<= 8; + confidence |= packet->data[4]; + + return packet->data[0]; +} + +/**************************************************************************/ +/*! + @brief Ask the sensor for the number of templates stored in memory. The + number is stored in <b>templateCount</b> on success. + @returns <code>FINGERPRINT_OK</code> on success + @returns <code>FINGERPRINT_PACKETRECIEVEERR</code> on communication error +*/ +/**************************************************************************/ +uint8_t Fingerprint::getTemplateCount(void) { + GET_CMD_PACKET(FINGERPRINT_TEMPLATECOUNT); + + templateCount = packet->data[1]; + templateCount <<= 8; + templateCount |= packet->data[2]; + + return packet->data[0]; +} + +/**************************************************************************/ +/*! + @brief Set the password on the sensor (future communication will require + password verification so don't forget it!!!) + @param password 32-bit password code + @returns <code>FINGERPRINT_OK</code> on success + @returns <code>FINGERPRINT_PACKETRECIEVEERR</code> on communication error +*/ +/**************************************************************************/ +uint8_t Fingerprint::setPassword(uint32_t password) { + SEND_CMD_PACKET(FINGERPRINT_SETPASSWORD, (password >> 24), (password >> 16), + (password >> 8), password); +} + +/**************************************************************************/ +/*! + @brief Helper function to process a packet and send it over UART to the + sensor + @param packet A structure containing the bytes to transmit +*/ +/**************************************************************************/ + +void Fingerprint::writeStructuredPacket(const Fingerprint_Packet &packet) +{ + R503Serial.putc((uint8_t)(packet->start_code >> 8)); + R503Serial.putc((uint8_t)(packet->start_code & 0xFF)); + R503Serial.putc(packet->address[0]); + R503Serial.putc(packet->address[1]); + R503Serial.putc(packet->address[2]); + R503Serial.putc(packet->address[3]); + R503Serial.putc(packet->type); + + uint16_t wire_length = packet->length + 2; + R503Serial.putc((uint8_t)(wire_length >> 8)); + R503Serial.putc((uint8_t)(wire_length & 0xFF)); + +#ifdef FINGERPRINT_DEBUG + Serial.print(". 0x"); + Serial.print((uint8_t)(packet->start_code >> 8), HEX); + Serial.print(", 0x"); + Serial.print((uint8_t)(packet->start_code & 0xFF), HEX); + Serial.print(", 0x"); + Serial.print(packet->address[0], HEX); + Serial.print(", 0x"); + Serial.print(packet->address[1], HEX); + Serial.print(", 0x"); + Serial.print(packet->address[2], HEX); + Serial.print(", 0x"); + Serial.print(packet->address[3], HEX); + Serial.print(", 0x"); + Serial.print(packet->type, HEX); + Serial.print(", 0x"); + Serial.print((uint8_t)(wire_length >> 8), HEX); + Serial.print(", 0x"); + Serial.print((uint8_t)(wire_length & 0xFF), HEX); +#endif + + uint16_t sum = ((wire_length) >> 8) + ((wire_length)&0xFF) + packet->type; + for (uint8_t i = 0; i < packet->length; i++) { + R503Serial.putc(packet->data[i]); + sum += packet->data[i]; +#ifdef FINGERPRINT_DEBUG + Serial.print(", 0x"); + Serial.print(packet->data[i], HEX); +#endif + } + + R503Serial.putc((uint8_t)(sum >> 8)); + R503Serial.putc((uint8_t)(sum & 0xFF)); + +#ifdef FINGERPRINT_DEBUG + Serial.print(", 0x"); + Serial.print((uint8_t)(sum >> 8), HEX); + Serial.print(", 0x"); + Serial.println((uint8_t)(sum & 0xFF), HEX); +#endif + + return; +} + +/**************************************************************************/ +/*! + @brief Helper function to receive data over UART from the sensor and + process it into a packet + @param packet A structure containing the bytes received + @param timeout how many milliseconds we're willing to wait + @returns <code>FINGERPRINT_OK</code> on success + @returns <code>FINGERPRINT_TIMEOUT</code> or + <code>FINGERPRINT_BADPACKET</code> on failure +*/ +/**************************************************************************/ +uint8_t +Fingerprint::getStructuredPacket(Fingerprint_Packet *packet, + uint16_t timeout) { + uint8_t byte; + uint16_t idx = 0, timer = 0; + +#ifdef FINGERPRINT_DEBUG + Serial.print("<- "); +#endif + + while (true) { + while (!R503Serial.readable()) { + wait_ms(1); + timer++; + if (timer >= timeout) { +#ifdef FINGERPRINT_DEBUG + Serial.println("Timed out"); +#endif + return FINGERPRINT_TIMEOUT; + } + } + byte = R503Serial.getc(); +#ifdef FINGERPRINT_DEBUG + Serial.print("0x"); + Serial.print(byte, HEX); + Serial.print(", "); +#endif + switch (idx) { + case 0: + if (byte != (FINGERPRINT_STARTCODE >> 8)) + continue; + packet->start_code = (uint16_t)byte << 8; + break; + case 1: + packet->start_code |= byte; + if (packet->start_code != FINGERPRINT_STARTCODE) + return FINGERPRINT_BADPACKET; + break; + case 2: + case 3: + case 4: + case 5: + packet->address[idx - 2] = byte; + break; + case 6: + packet->type = byte; + break; + case 7: + packet->length = (uint16_t)byte << 8; + break; + case 8: + packet->length |= byte; + break; + default: + packet->data[idx - 9] = byte; + if ((idx - 8) == packet->length) { +#ifdef FINGERPRINT_DEBUG + Serial.println(" OK "); +#endif + return FINGERPRINT_OK; + } + break; + } + idx++; + } + // Shouldn't get here so... + return FINGERPRINT_BADPACKET; +}
diff -r 000000000000 -r 35cd316e4b41 Fingerprint.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Fingerprint.h Tue Mar 16 16:31:41 2021 +0000 @@ -0,0 +1,186 @@ +#ifndef FINGERPRINT_H +#define FINGERPRINT_H + +/*! + * @file Fingerprint.h + */ +#include "mbed.h" +#include <string.h> + +typedef unsigned char uint8_t ; +//typedef unsigned int uint16_t; +//typedef unsigned long uint32_t; + +#define FINGERPRINT_OK 0x00 //!< Command execution is complete +#define FINGERPRINT_PACKETRECIEVEERR 0x01 //!< Error when receiving data package +#define FINGERPRINT_NOFINGER 0x02 //!< No finger on the sensor +#define FINGERPRINT_IMAGEFAIL 0x03 //!< Failed to enroll the finger +#define FINGERPRINT_IMAGEMESS \ + 0x06 //!< Failed to generate character file due to overly disorderly + //!< fingerprint image +#define FINGERPRINT_FEATUREFAIL \ + 0x07 //!< Failed to generate character file due to the lack of character point + //!< or small fingerprint image +#define FINGERPRINT_NOMATCH 0x08 //!< Finger doesn't match +#define FINGERPRINT_NOTFOUND 0x09 //!< Failed to find matching finger +#define FINGERPRINT_ENROLLMISMATCH \ + 0x0A //!< Failed to combine the character files +#define FINGERPRINT_BADLOCATION \ + 0x0B //!< Addressed PageID is beyond the finger library +#define FINGERPRINT_DBRANGEFAIL \ + 0x0C //!< Error when reading template from library or invalid template +#define FINGERPRINT_UPLOADFEATUREFAIL 0x0D //!< Error when uploading template +#define FINGERPRINT_PACKETRESPONSEFAIL \ + 0x0E //!< Module failed to receive the following data packages +#define FINGERPRINT_UPLOADFAIL 0x0F //!< Error when uploading image +#define FINGERPRINT_DELETEFAIL 0x10 //!< Failed to delete the template +#define FINGERPRINT_DBCLEARFAIL 0x11 //!< Failed to clear finger library +#define FINGERPRINT_PASSFAIL \ + 0x13 //!< Find whether the fingerprint passed or failed +#define FINGERPRINT_INVALIDIMAGE \ + 0x15 //!< Failed to generate image because of lac of valid primary image +#define FINGERPRINT_FLASHERR 0x18 //!< Error when writing flash +#define FINGERPRINT_INVALIDREG 0x1A //!< Invalid register number +#define FINGERPRINT_ADDRCODE 0x20 //!< Address code +#define FINGERPRINT_PASSVERIFY 0x21 //!< Verify the fingerprint passed +#define FINGERPRINT_STARTCODE \ + 0xEF01 //!< Fixed falue of EF01H; High byte transferred first + +#define FINGERPRINT_COMMANDPACKET 0x1 //!< Command packet +#define FINGERPRINT_DATAPACKET \ + 0x2 //!< Data packet, must follow command packet or acknowledge packet +#define FINGERPRINT_ACKPACKET 0x7 //!< Acknowledge packet +#define FINGERPRINT_ENDDATAPACKET 0x8 //!< End of data packet + +#define FINGERPRINT_TIMEOUT 0xFF //!< Timeout was reached +#define FINGERPRINT_BADPACKET 0xFE //!< Bad packet was sent + +#define FINGERPRINT_GETIMAGE 0x01 //!< Collect finger image +#define FINGERPRINT_IMAGE2TZ 0x02 //!< Generate character file from image +#define FINGERPRINT_SEARCH 0x04 //!< Search for fingerprint in slot +#define FINGERPRINT_REGMODEL \ + 0x05 //!< Combine character files and generate template +#define FINGERPRINT_STORE 0x06 //!< Store template +#define FINGERPRINT_LOAD 0x07 //!< Read/load template +#define FINGERPRINT_UPLOAD 0x08 //!< Upload template +#define FINGERPRINT_DELETE 0x0C //!< Delete templates +#define FINGERPRINT_EMPTY 0x0D //!< Empty library +#define FINGERPRINT_READSYSPARAM 0x0F //!< Read system parameters +#define FINGERPRINT_SETPASSWORD 0x12 //!< Sets passwords +#define FINGERPRINT_VERIFYPASSWORD 0x13 //!< Verifies the password +#define FINGERPRINT_HISPEEDSEARCH \ + 0x1B //!< Asks the sensor to search for a matching fingerprint template to the + //!< last model generated +#define FINGERPRINT_TEMPLATECOUNT 0x1D //!< Read finger template numbers +#define FINGERPRINT_AURALEDCONFIG 0x35 //!< Aura LED control +#define FINGERPRINT_LEDON 0x50 //!< Turn on the onboard LED +#define FINGERPRINT_LEDOFF 0x51 //!< Turn off the onboard LED + +#define FINGERPRINT_LED_BREATHING 0x01 //!< Breathing light +#define FINGERPRINT_LED_FLASHING 0x02 //!< Flashing light +#define FINGERPRINT_LED_ON 0x03 //!< Always on +#define FINGERPRINT_LED_OFF 0x04 //!< Always off +#define FINGERPRINT_LED_GRADUAL_ON 0x05 //!< Gradually on +#define FINGERPRINT_LED_GRADUAL_OFF 0x06 //!< Gradually off +#define FINGERPRINT_LED_RED 0x01 //!< Red LED +#define FINGERPRINT_LED_BLUE 0x02 //!< Blue LED +#define FINGERPRINT_LED_PURPLE 0x03 //!< Purple LED + +//#define FINGERPRINT_DEBUG + +#define DEFAULTTIMEOUT 1000 //!< UART reading timeout in milliseconds + +///! Helper class to craft UART packets +struct Fingerprint_Packet +{ + /**************************************************************************/ + /*! + @brief Create a new UART-borne packet + @param type Command, data, ack type packet + @param length Size of payload + @param data Pointer to bytes of size length we will memcopy into the + internal buffer + */ + /**************************************************************************/ + + Fingerprint_Packet(uint8_t type, uint16_t length, uint8_t *data) + { + this->start_code = FINGERPRINT_STARTCODE; + this->type = type; + this->length = length; + address[0] = 0xFF; + address[1] = 0xFF; + address[2] = 0xFF; + address[3] = 0xFF; + if (length < 64) + memcpy(this->data, data, length); + else + memcpy(this->data, data, 64); + } + uint16_t start_code; ///< "Wakeup" code for packet detection + uint8_t address[4]; ///< 32-bit Fingerprint sensor address + uint8_t type; ///< Type of packet + uint16_t length; ///< Length of packet + uint8_t data[64]; ///< The raw buffer for packet payload +}; + +///! Helper class to communicate with and keep state for fingerprint sensors +class Fingerprint { +public: + +// Fingerprint(Stream *serial, uint32_t password = 0x0); + Fingerprint(PinName serialTX, PinName serialRX, PinName reset, uint32_t password = 0x0); + + void begin(uint32_t baud); + + bool verifyPassword(void); + uint8_t getParameters(void); + + uint8_t getImage(void); + uint8_t image2Tz(uint8_t slot = 1); + uint8_t createModel(void); + + uint8_t emptyDatabase(void); + uint8_t storeModel(uint16_t id); + uint8_t loadModel(uint16_t id); + uint8_t getModel(void); + uint8_t deleteModel(uint16_t id); + uint8_t fingerFastSearch(void); + uint8_t fingerSearch(uint8_t slot = 1); + uint8_t getTemplateCount(void); + uint8_t setPassword(uint32_t password); + uint8_t LEDcontrol(bool on); + uint8_t LEDcontrol(uint8_t control, uint8_t speed, uint8_t coloridx, uint8_t count = 0); + + void writeStructuredPacket(const Fingerprint_Packet &p); + uint8_t getStructuredPacket(Fingerprint_Packet *p, + uint16_t timeout = DEFAULTTIMEOUT); + + /// The matching location that is set by fingerFastSearch() + uint16_t fingerID; + /// The confidence of the fingerFastSearch() match, higher numbers are more + /// confidents + uint16_t confidence; + /// The number of stored templates in the sensor, set by getTemplateCount() + uint16_t templateCount; + + uint16_t status_reg; ///< The status register (set by getParameters) + uint16_t system_id; ///< The system identifier (set by getParameters) + uint16_t capacity; ///< The fingerprint capacity (set by getParameters) + uint16_t security_level; ///< The security level (set by getParameters) + uint32_t device_addr; ///< The device address (set by getParameters) + uint16_t packet_len; ///< The max packet length (set by getParameters) + uint16_t baud_rate; ///< The UART baud rate (set by getParameters) + +private: + uint8_t checkPassword(void); + uint32_t thePassword; + uint32_t theAddress; + uint8_t recvPacket[20]; + +protected: + Serial R503Serial; + DigitalOut _reset; +}; + +#endif