emulation_layer_f.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_F_EMULATION_LAYER_F_HPP
#define M5_UNIT_NFC_NFC_LAYER_F_EMULATION_LAYER_F_HPP
 
#include "nfc/f/nfcf.hpp"
#include <m5_utility/compatibility_feature.hpp>
#include <vector>
#include <memory>
 
namespace m5 {
 
namespace unit {
class UnitST25R3916;
class CapST25R3916;
}  // namespace unit
 
namespace nfc {
 
class EmulationLayerF {
public:
    enum class State { None, Off, Communicated, Selected };
 
    struct Adapter;
    explicit EmulationLayerF(m5::unit::UnitST25R3916& u);
    explicit EmulationLayerF(m5::unit::CapST25R3916& u);
    virtual ~EmulationLayerF();
 
    inline State state() const
    {
        return _state;
    }
    inline const m5::nfc::f::PICC& emulatePICC() const
    {
        return _picc;
    }
    inline uint32_t expiredTime() const
    {
        return _expired_ms;
    }
    void setExpiredTime(const uint32_t ms)
    {
        _expired_ms = ms;
    }
 
    bool begin(const m5::nfc::f::PICC& picc, uint8_t* ptr, const uint32_t size);
    bool end();
    void update();
 
    virtual State receive_callback(const State s, const uint8_t* rx, const uint32_t rx_len);
 
protected:
    /*
      Return to State::Off when the current state has lasted longer than the expiration time
      @note Called at the top of update(). Does nothing while the time is zero, or in None/Off
     */
    void update_expired();
    /*
      Send a response to the reader
      @param tx Transmit buffer
      @param tx_len Transmit length
      @param timeout_ms Timeout in milliseconds
      @return True if successful
     */
    bool transmit(const uint8_t* tx, const uint16_t tx_len, const uint32_t timeout_ms);
 
private:
    void update_off();
    void update_communicated();
    void update_selected();
 
protected:
    uint8_t* _memory{};
    uint32_t _memory_size{};
 
private:
    State _state{}, _prev{};
    uint32_t _expired_ms{10 * 1000u};
    m5::utility::elapsed_time_t _activity_at{};  // When RF traffic or a state change was last seen
    std::unique_ptr<Adapter> _impl;
    m5::nfc::f::PICC _picc{};
};
 
// Impl for units
struct EmulationLayerF::Adapter {
    virtual ~Adapter() = default;
 
    virtual bool start_emulation(const m5::nfc::f::PICC& picc)                                 = 0;
    virtual bool stop_emulation()                                                              = 0;
    virtual bool transmit(const uint8_t* tx, const uint16_t tx_len, const uint32_t timeout_ms) = 0;
 
    virtual EmulationLayerF::State update_off()          = 0;
    virtual EmulationLayerF::State update_communicated() = 0;
    virtual EmulationLayerF::State update_selected()     = 0;
 
    // Put the chip back to where it waits for a reader, from whatever state it is in. The default
    // does nothing, so an adapter that has no such step keeps working
    virtual EmulationLayerF::State reset_to_off()
    {
        return EmulationLayerF::State::Off;
    }
 
    // Whether the chip saw RF traffic since this was last asked, which also clears it. Answers the
    // chip sends by itself are included, since they never reach receive_callback. The default says
    // no, so an adapter that cannot tell falls back to timing state changes alone
    virtual bool consume_rf_activity()
    {
        return false;
    }
};
 
}  // namespace nfc
}  // namespace m5
#endif