nfc_layer_b.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_B_HPP
#define M5_UNIT_NFC_NFC_LAYER_NFC_LAYER_B_HPP
 
#include "nfc/layer/nfc_layer.hpp"
#include "nfc/b/nfcb.hpp"
#include "nfc/isoDEP/isoDEP.hpp"
#include "nfc/layer/ndef_layer.hpp"
#include <vector>
#include <memory>
 
namespace m5 {
 
namespace unit {
class UnitST25R3916;
class CapST25R3916;
class UnitWS1850S;
}  // namespace unit
namespace nfc {
 
class NFCLayerB : public NFCLayerInterface {
public:
    struct Adapter;
    explicit NFCLayerB(m5::unit::UnitST25R3916& u);
    explicit NFCLayerB(m5::unit::CapST25R3916& u);
    explicit NFCLayerB(m5::unit::UnitWS1850S& u);
    virtual ~NFCLayerB();
 
    virtual bool transceive(uint8_t* rx, uint16_t& rx_len, const uint8_t* tx, const uint16_t tx_len,
                            const uint32_t timeout_ms) override;
    virtual bool transmit(const uint8_t* tx, const uint16_t tx_len, const uint32_t timeout_ms) override;
    virtual bool receive(uint8_t* rx, uint16_t& rx_len, const uint32_t timeout_ms) override;
    virtual m5::nfc::isodep::IsoDEP* isoDEP() override
    {
        return &_isoDEP;
    }
    virtual uint16_t maximum_fifo_depth() const override;
 
    inline bool isActive(const m5::nfc::b::PICC& picc) const
    {
        return _activePICC.valid() && _activePICC == picc;
    }
    const m5::nfc::b::PICC& activatedPICC() const
    {
        return _activePICC;
    }
 
 
    inline bool request(uint8_t* atqb, uint16_t& atqb_len, const uint8_t afi = 0x00,
                        const m5::nfc::b::Require slots = m5::nfc::b::Require::Slot1,
                        const uint32_t timeout_ms       = m5::nfc::b::TIMEOUT_REQ_WUP_B)
    {
        return request_wakeup(atqb, atqb_len, afi, slots, false, timeout_ms);
    }
    inline bool wakeup(uint8_t* atqb, uint16_t& atqb_len, const uint8_t afi = 0x00,
                       const m5::nfc::b::Require slots = m5::nfc::b::Require::Slot1,
                       const uint32_t timeout_ms       = m5::nfc::b::TIMEOUT_REQ_WUP_B)
    {
        return request_wakeup(atqb, atqb_len, afi, slots, true, timeout_ms);
    }
 
    bool detect(m5::nfc::b::PICC& picc, const uint8_t afi = 0x00, const uint32_t timeout_ms = 50U,
                const uint32_t req_timeout_ms = m5::nfc::b::TIMEOUT_REQ_WUP_B);
    bool detect(std::vector<m5::nfc::b::PICC>& piccs, const uint8_t afi = 0x00, const uint8_t max_piccs = 4,
                const uint32_t timeout_ms = 1000U, const uint32_t req_timeout_ms = m5::nfc::b::TIMEOUT_REQ_WUP_B);
 
    bool select(m5::nfc::b::PICC& picc, const uint32_t timeout_ms = m5::nfc::b::TIMEOUT_ATTRIB);
#if 0
    bool activate(m5::nfc::b::PICC& picc);
    bool reactivate(const m5::nfc::b::PICC& picc);
    inline bool reactivate()
    {
        return reactivate(_activePICC);
    }
#endif
 
 
 
    bool hlt(const uint8_t pupi[4], const uint32_t timeout_ms = m5::nfc::b::TIMEOUT_HLTB);
    bool deselect(const uint8_t pupi[4], const uint8_t cid = 0xFF,
                  const uint32_t timeout_ms = m5::nfc::b::TIMEOUT_DESELECT);
    bool deactivate();
 
protected:
    bool request_wakeup(uint8_t* atqb, uint16_t& atqb_len, const uint8_t afi, const m5::nfc::b::Require slots,
                        const bool wakeup, const uint32_t timeout_ms = m5::nfc::b::TIMEOUT_REQ_WUP_B);
 
    virtual bool read(uint8_t* rx, uint16_t& rx_len, const uint16_t saddr) override
    {
        return false;
    }
    virtual bool write(const uint16_t saddr, const uint8_t* tx, const uint16_t tx_len) override
    {
        return false;
    }
    inline virtual uint16_t first_user_block() const override
    {
        return 0;
    }
    inline virtual uint16_t last_user_block() const override
    {
        return 0;
    }
    inline virtual uint16_t user_area_size() const override
    {
        return 0;
    }
    inline virtual uint16_t unit_size_read() const override
    {
        return 0;
    }
    inline virtual uint16_t unit_size_write() const override
    {
        return 0;
    }
 
protected:
    m5::nfc::b::PICC _activePICC{};
    m5::nfc::ndef::NDEFLayer _ndef;
    m5::nfc::isodep::IsoDEP _isoDEP;
 
private:
    std::unique_ptr<Adapter> _impl;
};
 
// Impl for units
struct NFCLayerB::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)                                         = 0;
    virtual bool transmit(const uint8_t* tx, const uint16_t tx_len, const uint32_t timeout_ms) = 0;
    virtual bool receive(uint8_t* rx, uint16_t& rx_len, const uint32_t timeout_ms)             = 0;
};
 
}  // namespace nfc
}  // namespace m5
 
#endif