sfDevFPC2534.h

Go to the documentation of this file.

 
// Header file for the main class of the library.
 
#pragma once
 
// from the FPC SDK
#include "fpc_api.h"
 
// The interface definition for communication classes
#include "sfDevFPC2534IComm.h"
 
// This library is dependent on Arduino framework
#include <Arduino.h>
 
// Define the LED pin on the FPC2534 board
const uint8_t SPARKFUN_FPC2534_LED_PIN = 1;
 
// The design pattern that the library implements follows the standard implementation
// pattern of the FPC SDK - response from the sensor is delivered via callback functions.
//
// Define a struct that can hold all the callback functions
// that the library can call on events from the sensor
 
typedef struct
{
    void (*on_error)(uint16_t error);
    void (*on_status)(uint16_t event, uint16_t state);
    void (*on_version)(char *version);
    void (*on_enroll)(uint8_t feedback, uint8_t samples_remaining);
    void (*on_identify)(bool is_match, uint16_t id);
    void (*on_list_templates)(uint16_t num_templates, uint16_t *template_ids);
    void (*on_navigation)(uint16_t gesture);
    void (*on_gpio_control)(uint8_t state);
    void (*on_system_config_get)(fpc_system_config_t *cfg);
    void (*on_bist_done)(uint16_t test_verdict);
    void (*on_data_transfer_done)(uint8_t *data, size_t size);
    void (*on_mode_change)(uint16_t new_mode);
    void (*on_finger_change)(bool present);
    void (*on_is_ready_change)(bool isReady);
 
} sfDevFPC2534Callbacks_t;
 
class sfDevFPC2534
{
  public:
    sfDevFPC2534();
 
    fpc_result_t requestStatus(void);
 
    fpc_result_t requestVersion(void);
 
    fpc_result_t requestEnroll(fpc_id_type_t &id);
 
    fpc_result_t requestIdentify(fpc_id_type_t &id, uint16_t tag);
 
    fpc_result_t requestAbort(void);
 
    fpc_result_t requestListTemplates(void);
 
    fpc_result_t requestDeleteTemplate(fpc_id_type_t &id);
 
    fpc_result_t sendReset(void);
 
    // fpc_result_t requestCryptoKey(void);
 
    fpc_result_t startNavigationMode(uint8_t orientation);
 
    fpc_result_t startBuiltInSelfTest(void);
 
    fpc_result_t requestSetGPIO(uint8_t pin, uint8_t mode, uint8_t state);
 
    fpc_result_t requestGetGPIO(uint8_t pin);
 
    fpc_result_t setSystemConfig(fpc_system_config_t *cfg);
 
    fpc_result_t requestGetSystemConfig(uint8_t type);
 
    // /**
    //  * @brief Populate and transfer a CMD_PUT_TEMPLATE_DATA request
    //  *
    //  * Send template to device.
    //  *
    //  * @param id   Template id.
    //  * @param data Pointer to template data.
    //  * @param size Size of template data.
    //  *
    //  * @return Result Code
    //  */
    // fpc_result_t requestPutTemplateData(uint16_t id, uint8_t *data, size_t size);
 
    // /**
    //  * @brief Populate and transfer a CMD_GET_TEMPLATE_DATA request.
    //  *
    //  * Read template from device. This function will allocate memory for the template and
    //  * return data and size in the callback function (on_data_transfer_done).
    //  *
    //  * @param id Template id.
    //  *
    //  * @return Result Code
    //  */
    // fpc_result_t requestGetTemplateData(uint16_t id);
 
    fpc_result_t factoryReset(void);
 
    uint16_t currentMode(void) const
    {
        return _current_state & (STATE_ENROLL | STATE_IDENTIFY | STATE_NAVIGATION);
    }
 
    bool isFingerPresent(void) const
    {
        return _finger_present;
    }
 
    // for the library to actually work, user provided callbacks are needed ...
    void setCallbacks(const sfDevFPC2534Callbacks_t &callbacks)
    {
        _callbacks = callbacks;
    }
 
    bool initialize(sfDevFPC2534IComm &comm)
    {
        _comm = &comm;
        return true;
    }
 
    bool isReady(void) const
    {
        return (_current_state & STATE_APP_FW_READY) == STATE_APP_FW_READY;
    }
 
    bool isDataAvailable(void) const
    {
        if (_comm == nullptr)
            return false;
        return _comm->dataAvailable();
    }
 
    void clearData(void)
    {
        if (_comm != nullptr)
            _comm->clearData();
    }
    fpc_result_t setLED(bool on = true);
 
    // Process the next response from the device
    // If flushNone is true, it will skip over any EVENT_NONE events
 
    fpc_result_t processNextResponse(bool flushNone);
    fpc_result_t processNextResponse(void)
    {
        return processNextResponse(false);
    };
 
  private:
    // NOTE:
    // In general, messages are received from the device, identified and sent to the
    // appropriate parser function.
 
    fpc_result_t sendCommand(fpc_cmd_hdr_t &cmd, size_t size);
    fpc_result_t parseStatusCommand(fpc_cmd_hdr_t *, size_t);
    fpc_result_t parseVersionCommand(fpc_cmd_hdr_t *, size_t);
    fpc_result_t parseEnrollStatusCommand(fpc_cmd_hdr_t *, size_t);
    fpc_result_t parseIdentifyCommand(fpc_cmd_hdr_t *, size_t);
    fpc_result_t parseListTemplatesCommand(fpc_cmd_hdr_t *, size_t);
    fpc_result_t parseNavigationEventCommand(fpc_cmd_hdr_t *, size_t);
    fpc_result_t parseGPIOControlCommand(fpc_cmd_hdr_t *, size_t);
    fpc_result_t parseGetSystemConfigCommand(fpc_cmd_hdr_t *, size_t);
    fpc_result_t parseBISTCommand(fpc_cmd_hdr_t *, size_t);
    fpc_result_t parseCommand(uint8_t *frame_payload, size_t payload_size);
 
    bool checkForNoneEvent(uint8_t *payload, size_t size);
    fpc_result_t flushNoneEvent(void);
 
    // internal pointer to the communication interface. The comm device being used (I2C, Serial) is abstract
    // to the library via this interface.
    sfDevFPC2534IComm *_comm = nullptr;
 
    // Internal copy of the callback functions
    sfDevFPC2534Callbacks_t _callbacks;
 
    // current state of the sensor
    uint16_t _current_state = 0;
 
    // Is a finger present?
    bool _finger_present = false;
};