unit_MFRC522.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_RFID_UNIT_MFRC522_HPP
#define M5_UNIT_RFID_UNIT_MFRC522_HPP
 
#include <M5UnitComponent.hpp>
// M5Unit-NFC
#include <nfc/nfc.hpp>
#include <nfc/a/nfca.hpp>
 
namespace m5 {
namespace unit {
 
namespace nfc {
struct AdapterMFRC522;  // For layer
}
 
namespace mfrc522 {
 
constexpr uint16_t MAX_FIFO_DEPTH{64};  
 
enum class Command : uint8_t {
    Idle,                
    Mem,                 
    GenerateRandomID,    
    CalcCRC,             
    Transmit,            
    NoCmdChange = 0x07,  
    Receive,             
    Transceive = 0x0C,   
    MFAuthent = 0x0E,    
    SoftReset,           
};
 
enum class ReceiverGain : uint8_t {
    dB18,  
    dB23,  
    // 2 = dB18 (duplicated),
    // 3 = dB23 (duplicated)
    dB33 = 0x04,  
    dB38,         
    dB43,         
    dB48,         
};
 
enum class Error : uint8_t {
    OCCUR_COLLISION,           
    UID_NOT_COMPLETED,         
    ARGUMENT = 0x80,           
    COMMUNICATION,             
    REGISTER,                  
    TIMEOUT,                   
    MIFARE_NACK,               
    CRC,                       
    AUTH,                      
    CANNOT_RESOLVE_COLLISION,  
    INTERNAL = 0xFE,           
    UNKNOWN  = 0xFF            
};
 
}  // namespace mfrc522
 
class UnitMFRC522 : public Component {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitMFRC522, 0x28);
 
public:
    struct config_t {
        m5::nfc::NFC mode{m5::nfc::NFC::A};
        uint8_t mode_reg{0x3D};
        bool enable_antenna{true};
        mfrc522::ReceiverGain receiver_gain{mfrc522::ReceiverGain::dB48};
        bool software_crc{false};
    };
 
    explicit UnitMFRC522(const uint8_t addr = DEFAULT_ADDRESS) : Component(addr)
    {
        auto ccfg  = component_config();
        ccfg.clock = 400 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitMFRC522()
    {
    }
 
    virtual bool begin() override;
    virtual void update(const bool force = false) override;
 
 
    inline config_t config()
    {
        return _cfg;
    }
    inline void config(const config_t& cfg)
    {
        _cfg = cfg;
    }
 
    inline virtual m5::nfc::NFC NFCMode() const
    {
        return m5::nfc::NFC::A;
    }
    inline virtual bool configureNFCMode(const m5::nfc::NFC mode)
    {
        // Nop
        return mode == m5::nfc::NFC::A;
    }
 
    bool softReset(const bool blocking = true);
 
    inline bool selfTest()
    {
        bool ret = self_test();
        return ret && begin();
    }
 
 
    bool readAntennaStatus(bool& status);
    bool turnOnAntenna();
    bool turnOffAntenna();
    bool readReceiverGain(mfrc522::ReceiverGain& gain);
    bool writeReceiverGain(const mfrc522::ReceiverGain gain);
 
 
    bool readGsN(uint8_t& value);
    bool writeGsN(const uint8_t value);
    bool readCWGsP(uint8_t& value);
    bool writeCWGsP(const uint8_t value);
    bool readModGsP(uint8_t& value);
    bool writeModGsP(const uint8_t value);
 
 
    bool readRxThreshold(uint8_t& value);
    bool writeRxThreshold(const uint8_t value);
 
 
    bool readTPrescaler(uint16_t& tprescale);
    bool writeTPrescaler(const uint16_t tprescale);
 
 
    bool calculateCRC(uint16_t& result, const uint8_t* buf, const uint8_t len);
    bool calculateSoftwareCRC(uint16_t& result, const uint8_t* buf, const uint8_t len);
 
 
    bool nfcaTransceive(uint8_t* rx, uint16_t& rx_len, const uint8_t* tx, const uint16_t tx_len,
                        const uint32_t timeout_ms);
 
    inline bool request(uint16_t& atqa)
    {
        return request_wakeup(atqa, true);
    }
    inline bool wakeup(uint16_t& atqa)
    {
        return request_wakeup(atqa, false);
    }
 
    bool selectWithAnticollision(bool& completed, m5::nfc::a::PICC& picc, const uint8_t lv);
    bool select(const m5::nfc::a::PICC& picc);
 
    bool readBlock(uint8_t rx[16], const uint8_t block);
    bool writeBlock(const uint8_t block, const uint8_t tx[16]);
    bool hlt();
 
 
    inline bool mifareClassicAuthenticateA(
        const m5::nfc::a::PICC& picc, const uint8_t block,
        const m5::nfc::a::mifare::classic::Key& key = m5::nfc::a::mifare::classic::DEFAULT_KEY)
    {
        return mifare_classic_authenticate(m5::nfc::a::Command::AUTH_WITH_KEY_A, picc, block, key);
    }
    inline bool mifareClassicAuthenticateB(
        const m5::nfc::a::PICC& picc, const uint8_t block,
        const m5::nfc::a::mifare::classic::Key& key = m5::nfc::a::mifare::classic::DEFAULT_KEY)
    {
        return mifare_classic_authenticate(m5::nfc::a::Command::AUTH_WITH_KEY_B, picc, block, key);
    }
 
    bool mifareClassicStopCrypto1();
 
    bool mifareClassicValueBlock(const m5::nfc::a::Command cmd, const uint8_t block, const uint32_t arg = 0);
 
protected:
    // register operation
    bool modify_bit_register8(const uint8_t reg, const uint8_t set_mask, const uint8_t clear_mask);
    bool set_bit_register8(const uint8_t reg, const uint8_t bits);
    bool clear_bit_register8(const uint8_t reg, const uint8_t bits);
    inline bool change_bit_register8(const uint8_t reg, const uint8_t bits, const uint8_t mask)
    {
        return modify_bit_register8(reg, mask & bits, mask);
    }
    bool read_register_with_align(const uint8_t reg, uint8_t* buf, const uint8_t len, const uint8_t align);
    bool write_pcd_command(const mfrc522::Command cmd);
 
    bool reset_baud_rates();
    bool flush_fifo_buffer();
    bool wait_comm_irq(const uint8_t irq, const uint32_t duration);
    bool wait_div_irq(const uint8_t irq, const uint32_t duration);
 
    // transceive
    bool transmit_command(const mfrc522::Command cmd, const uint8_t* buf, const uint8_t len, const uint8_t txLast = 0,
                          const uint8_t rxAlign = 0);
    bool transceive(uint8_t* rbuf, uint16_t& rlen, const uint8_t* buf, const uint16_t len, const uint32_t timeout_ms,
                    uint8_t& validBits, const uint8_t rxAlign = 0, const bool crc = false, uint8_t* err = nullptr);
 
    bool picc_haltA();
 
    // Read/Write
    bool read_block(uint8_t* rbuf, uint8_t& rlen, const uint8_t addr);
    bool write_block(const uint8_t block, const uint8_t* buf, const uint8_t len);
    bool write_page(const uint8_t page, const uint8_t* buf, const uint8_t len);
 
    // NFC-A
    bool request_wakeup(uint16_t& atqa, const bool request);
    bool anti_collision(const uint8_t cascadeLevel, uint8_t* buf);
 
    // MIFARE classic
    bool mifare_classic_authenticate(const m5::nfc::a::Command cmd, const m5::nfc::a::PICC& picc, const uint8_t block,
                                     const m5::nfc::a::mifare::classic::Key& key);
    bool mifare_classic_transceive(const m5::nfc::a::Command cmd, const uint8_t block, const uint32_t timeout_ms);
    bool mifare_classic_transceive(const uint8_t* buf, const uint8_t len, const uint32_t timeout_ms,
                                   const bool usingtimeout = false);
 
    // crc
    inline bool calculate_crc(uint16_t& result, const uint8_t* buf, const uint8_t len)
    {
        return (this->*(_cfg.software_crc ? &UnitMFRC522::calculateSoftwareCRC : &UnitMFRC522::calculateCRC))(result,
                                                                                                              buf, len);
    }
 
    virtual bool self_test();
 
protected:
    config_t _cfg{};
    uint16_t _tprescaler{};
};
 
namespace mfrc522 {
namespace command {
// Command and status
constexpr uint8_t COMMAND_REG{0x01};
constexpr uint8_t COM_IEN_REG{0x02};
constexpr uint8_t DIV_IEN_REG{0x03};
constexpr uint8_t COM_IRQ_REG{0x04};
constexpr uint8_t DIV_IRQ_REG{0x05};
constexpr uint8_t ERROR_REG{0x06};
constexpr uint8_t STATUS2_REG{0x08};
constexpr uint8_t FIFO_DATA_REG{0x09};
constexpr uint8_t FIFO_LEVEL_REG{0x0A};
constexpr uint8_t WATER_LEVEL_REG{0x0B};
constexpr uint8_t CONTROL_REG{0x0C};
constexpr uint8_t BIT_FRAMING_REG{0x0D};
constexpr uint8_t COLL_REG{0x0E};
 
// Communication
constexpr uint8_t MODE_REG{0x11};
constexpr uint8_t TX_MODE_REG{0x12};
constexpr uint8_t RX_MODE_REG{0x13};
constexpr uint8_t TX_CONTROL_REG{0x14};
constexpr uint8_t TX_ASK_REG{0x15};
constexpr uint8_t TX_SEL_REG{0x16};
constexpr uint8_t RX_SEL_REG{0x17};
constexpr uint8_t RX_THRESHOLD_REG{0x18};
constexpr uint8_t DEMOD_REG{0x19};
constexpr uint8_t MF_TX_REG{0x1C};
constexpr uint8_t MF_RX_REG{0x1D};
 
// Configuration
constexpr uint8_t CRC_RESULT_REGH{0x21};
constexpr uint8_t CRC_RESULT_REGL{0x22};
constexpr uint8_t MOD_WIDTH_REG{0x24};
constexpr uint8_t RFC_FG_REG{0x26};
constexpr uint8_t GSN_REG{0x27};
constexpr uint8_t CW_GSP_REG{0x28};
constexpr uint8_t MOD_GSP_REG{0x29};
constexpr uint8_t TMODE_REG{0x2A};
constexpr uint8_t TPRESCALER_REG_L{0x2B};
constexpr uint8_t TRELOAD_REG_H{0x2C};
constexpr uint8_t TRELOAD_REG_L{0x2D};
 
// Test
constexpr uint8_t AUTO_TEST_REG{0x36};
constexpr uint8_t VERSION_REG{0x37};
 
}  // namespace command
}  // namespace mfrc522
 
}  // namespace unit
}  // namespace m5
#endif