nfc_layer_v.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_NFC_NFC_LAYER_NFC_LAYER_V_HPP
#define M5_UNIT_NFC_NFC_LAYER_NFC_LAYER_V_HPP
 
#include "nfc/layer/nfc_layer.hpp"
#include "nfc/v/nfcv.hpp"
#include "nfc/layer/ndef_layer.hpp"
#include <vector>
#include <memory>
 
namespace m5 {
namespace unit {
class UnitST25R3916;
class CapST25R3916;
}  // namespace unit
namespace nfc {
 
class NFCLayerV : public NFCLayerInterface {
public:
    struct Adapter;
    explicit NFCLayerV(m5::unit::UnitST25R3916& u);
    explicit NFCLayerV(m5::unit::CapST25R3916& u);
    virtual ~NFCLayerV();
 
    virtual uint16_t maximum_fifo_depth() const override;
 
    inline bool isActive(const m5::nfc::v::PICC& picc) const
    {
        return _activePICC.valid() && _activePICC == picc;
    }
    const m5::nfc::v::PICC& activatedPICC() const
    {
        return _activePICC;
    }
 
    inline m5::nfc::v::ModulationMode modulationMode() const
    {
        return _modulation;
    }
    inline void setModulationMode(const m5::nfc::v::ModulationMode mode)
    {
        _modulation = mode;
    }
 
 
    bool detect(m5::nfc::v::PICC& picc, const uint32_t timeout_ms = 50U);
    bool detect(std::vector<m5::nfc::v::PICC>& piccs, const uint32_t timeout_ms = 1000U);
 
    bool activate(const m5::nfc::v::PICC& picc);
 
    bool reactivate(const m5::nfc::v::PICC& picc);
    inline bool reactivate()
    {
        return reactivate(_activePICC);
    }
 
 
    bool deactivate();
    bool readBlock(uint8_t rx[32], const uint16_t block);
    bool writeBlock(const uint16_t block, const uint8_t* tx, const uint8_t tx_len);
    virtual bool read(uint8_t* rx, uint16_t& rx_len, const uint16_t sblock) override;
    virtual bool write(const uint16_t sblock, const uint8_t* tx, const uint16_t tx_len) override;
 
    bool dump();
    bool dump(const uint16_t block);
 
 
    bool ndefIsValidFormat(bool& valid);
    bool ndefReadCapabilityContainer(m5::nfc::ndef::type5::CapabilityContainer& cc);
    bool ndefWriteCapabilityContainer(const m5::nfc::ndef::type5::CapabilityContainer& cc);
    bool ndefRead(m5::nfc::ndef::TLV& msg);
    bool ndefWrite(const m5::nfc::ndef::TLV& msg);
 
protected:
    bool dump_all();
    bool dump_block(const uint16_t block);
 
    bool detect_single(m5::nfc::v::PICC& picc);
    bool get_system_information(m5::nfc::v::PICC& picc);
    bool get_system_information_ext(m5::nfc::v::PICC& picc);
    void probe_memory_layout(m5::nfc::v::PICC& picc);
    bool probe_read_block(const m5::nfc::v::PICC& picc, const uint16_t block, uint8_t* rx, uint16_t& rx_len);
    bool read_block_ext(uint8_t rx[32], const m5::nfc::v::PICC& picc, const uint16_t block);
    bool write_block_ext(const m5::nfc::v::PICC& picc, const uint16_t block, const uint8_t* tx, const uint8_t tx_len);
    bool reset_to_ready(const m5::nfc::v::PICC* picc);
    bool stay_quiet(const m5::nfc::v::PICC& picc);
 
    virtual uint16_t first_user_block() const override
    {
        return _activePICC.firstUserBlock();
    }
    virtual uint16_t last_user_block() const override
    {
        return _activePICC.lastUserBlock();
    }
    inline virtual uint16_t user_area_size() const override
    {
        return _activePICC.userAreaSize();
    }
    inline virtual uint16_t unit_size_read() const override
    {
        return _activePICC.block_size;
    }
    inline virtual uint16_t unit_size_write() const override
    {
        return _activePICC.block_size;
    }
 
protected:
    m5::nfc::v::PICC _activePICC{};
 
private:
    std::unique_ptr<Adapter> _impl;
    m5::nfc::ndef::NDEFLayer _ndef;
    m5::nfc::v::ModulationMode _modulation{m5::nfc::v::ModulationMode::OneOf4};
};
 
// Impl for units
struct NFCLayerV::Adapter {
    virtual ~Adapter()                      = default;
    virtual uint16_t max_fifo_depth() const = 0;
 
    virtual bool transceive(uint8_t* rx, uint16_t& rx_len, const uint8_t* tx, const uint16_t tx_len,
                            const uint32_t timeout_ms, const m5::nfc::v::ModulationMode mode) = 0;
    virtual bool transmit(const uint8_t* tx, const uint16_t tx_len, const uint32_t timeout_ms,
                          const m5::nfc::v::ModulationMode mode)                              = 0;
    virtual bool receive(uint8_t* rx, uint16_t& rx_len, const uint32_t timeout_ms)            = 0;
};
 
}  // namespace nfc
}  // namespace m5
#endif