.. _program_listing_file_libspookyaction_include_pn532_data.hpp:

Program Listing for File data.hpp
=================================

|exhale_lsh| :ref:`Return to documentation for file <file_libspookyaction_include_pn532_data.hpp>` (``libspookyaction/include/pn532/data.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   //
   // Created by Pietro Saccardi on 22/12/2020.
   //
   
   #ifndef PN532_DATA_HPP
   #define PN532_DATA_HPP
   
   #include <mlab/bin_data.hpp>
   #include <mlab/result.hpp>
   #include <pn532/bits.hpp>
   #include <pn532/log.h>
   #include <pn532/msg.hpp>
   
   namespace pn532 {
       using target_kbps106_typea = target<baudrate_modulation::kbps106_iso_iec_14443_typea>;
       using target_kbps212_felica = target<baudrate_modulation::kbps212_felica>;
       using target_kbps424_felica = target<baudrate_modulation::kbps424_felica>;
       using target_kbps106_typeb = target<baudrate_modulation::kbps106_iso_iec_14443_3_typeb>;
       using target_kbps106_jewel_tag = target<baudrate_modulation::kbps106_innovision_jewel_tag>;
   
       struct infty_t {
       };
   
       static constexpr infty_t infty{};
   
       template <class Integral>
       struct with_inf {
           static_assert(std::is_integral_v<Integral> and not std::is_same_v<Integral, bool>);
           Integral v = Integral{};
   
           with_inf() = default;
   
           inline with_inf(infty_t) : v{std::numeric_limits<Integral>::max()} {}
   
           inline with_inf(Integral n) : v{n} {}
   
           with_inf(bool) = delete;
   
           inline operator Integral() const { return v; }
   
           inline with_inf &operator=(infty_t) {
               v = std::numeric_limits<Integral>::max();
               return *this;
           }
   
           inline bool operator==(infty_t) const { return v == std::numeric_limits<Integral>::max(); }
           inline bool operator!=(infty_t) const { return v != std::numeric_limits<Integral>::max(); }
       };
   
       using infbyte = with_inf<std::uint8_t>;
   
       template <target_type Type>
       struct poll_target : public target<baudrate_modulation_of(Type)> {
       };
   
       struct poll_target_with_atr {
           atr_res_info atr_info;
       };
   
       template <baudrate_modulation BrMd>
       struct poll_target_dep_passive : public target<BrMd>, public poll_target_with_atr {
       };
   
       template <>
       struct poll_target<target_type::dep_passive_106kbps> : public poll_target_dep_passive<
                                                                      baudrate_modulation_of(target_type::dep_passive_106kbps)> {
       };
   
       template <>
       struct poll_target<target_type::dep_passive_212kbps> : public poll_target_dep_passive<
                                                                      baudrate_modulation_of(target_type::dep_passive_212kbps)> {
       };
   
       template <>
       struct poll_target<target_type::dep_passive_424kbps> : public poll_target_dep_passive<
                                                                      baudrate_modulation_of(target_type::dep_passive_424kbps)> {
       };
   
       template <>
       struct poll_target<target_type::dep_active_106kbps> : public poll_target_with_atr {
       };
   
       template <>
       struct poll_target<target_type::dep_active_212kbps> : public poll_target_with_atr {
       };
   
       template <>
       struct poll_target<target_type::dep_active_424kbps> : public poll_target_with_atr {
       };
   
       class any_poll_target : public mlab::any_of<target_type, poll_target> {
       public:
           using mlab::any_of<target_type, poll_target>::any_of;
           explicit any_poll_target(enum_type) = delete;
       };
   
       enum struct gpio_port {
           p3, 
           p7, 
           i0i1
       };
   
       struct firmware_version {
           std::uint8_t ic;         
           std::uint8_t version;    
           std::uint8_t revision;   
           bool iso_18092;          
           bool iso_iec_14443_typea;
           bool iso_iec_14443_typeb;
       };
   
       struct rf_status {
           bool nad_present;         
           bool expect_more_info;    
           internal_error_code error;
   
           inline explicit operator bool() const;
       };
   
       struct parameters {
           bool use_nad_data;                     
           bool use_did_data;                     
           bool auto_generate_atr_res;            
           bool auto_generate_rats;               
           bool enable_iso_14443_4_picc_emulation;
           bool remove_pre_post_amble;            
       };
   
       struct general_status_target {
           std::uint8_t logical_index;
           baudrate baudrate_rx;      
           baudrate baudrate_tx;      
           modulation modulation_type;
       };
   
       struct general_status_sam {
           bool neg_pulse_on_clad_line;
           bool detected_rf_field_off;
           bool timeout_after_sig_act_irq;
           bool clad_line_high;
       };
       struct general_status {
           internal_error_code last_error;            
           bool rf_field_present;                     
           std::vector<general_status_target> targets;
           general_status_sam sam;                    
       };
   
       struct status_as_target {
           nfcip1_picc_status status;
           baudrate initiator_speed; 
           baudrate target_speed;    
       };
   
       struct jump_dep_psl {
           rf_status status{};                 
           std::uint8_t target_logical_index{};
           atr_res_info atr_info;              
       };
   
       struct mifare_params {
           std::array<std::uint8_t, 2> sens_res;
           std::array<std::uint8_t, 3> nfcid_1t;
           std::uint8_t sel_res;                
       };
   
       struct felica_params {
           std::array<std::uint8_t, 8> nfcid_2t; 
           std::array<std::uint8_t, 8> pad;      
           std::array<std::uint8_t, 2> syst_code;
       };
   
       struct activation_as_target_mode {
           baudrate speed;                
           bool iso_iec_14443_4_picc;     
           bool dep;                      
           framing_as_target framing_type;
       };
   
       struct activation_as_target {
           activation_as_target_mode mode;             
           std::vector<std::uint8_t> initiator_command;
       };
   
       class gpio_status {
       private:
           std::uint8_t _p3_mask = 0x00;
           std::uint8_t _p7_mask = 0x00;
           std::uint8_t _i0i1_mask = 0x00;
   
       public:
           gpio_status() = default;
   
           inline gpio_status(std::uint8_t p3_mask, std::uint8_t p7_mask, std::uint8_t i0i1_mask);
   
           [[nodiscard]] inline std::uint8_t mask(gpio_port loc) const;
   
           inline void set_mask(gpio_port loc, std::uint8_t mask);
   
           [[nodiscard]] inline bool operator[](std::pair<gpio_port, std::uint8_t> const &gpio_idx) const;
   
           inline mlab::bit_ref operator[](std::pair<gpio_port, std::uint8_t> const &gpio_idx);
       };
   }// namespace pn532
   
   namespace mlab {
   #ifndef DOXYGEN_SHOULD_SKIP_THIS
       bin_data &operator<<(bin_data &bd, pn532::reg::ciu_212_424kbps const &reg);
   
       bin_data &operator<<(bin_data &bd, pn532::reg::ciu_106kbps_typea const &reg);
   
       bin_data &operator<<(bin_data &bd, pn532::reg::ciu_typeb const &reg);
   
       bin_data &operator<<(bin_data &bd, pn532::reg::ciu_iso_iec_14443_4_at_baudrate const &reg);
   
       bin_data &operator<<(bin_data &bd, pn532::reg::ciu_iso_iec_14443_4 const &reg);
   
       bin_data &operator<<(bin_data &bd, pn532::nfcid_2t const &uid);
   
       bin_data &operator<<(bin_data &bd, pn532::nfcid_3t const &uid);
   
       bin_data &operator<<(bin_data &bd, pn532::bits::reg_antenna_detector const &r);
   
       bin_data &operator<<(bin_data &s, pn532::parameters const &p);
   
       bin_data &operator<<(bin_data &s, std::vector<pn532::wakeup_source> const &vws);
   
       bin_data &operator<<(bin_data &s, pn532::mifare_params const &p);
   
       bin_data &operator<<(bin_data &s, pn532::felica_params const &p);
   
       template <pn532::baudrate_modulation BrMd>
       bin_stream &operator>>(bin_stream &s, std::vector<pn532::target<BrMd>> &targets);
   
       bin_stream &operator>>(bin_stream &s, pn532::poll_target<pn532::target_type::dep_passive_106kbps> &entry);
   
       template <pn532::target_type Type>
       bin_stream &operator>>(bin_stream &s, pn532::poll_target<Type> &entry);
   
       bin_stream &operator>>(bin_stream &s, pn532::any_poll_target &t);
   
       bin_stream &operator>>(bin_stream &s, std::vector<pn532::any_poll_target> &targets);
   
       bin_stream &operator>>(bin_stream &s, std::pair<pn532::rf_status, bin_data> &status_data_pair);
   
       bin_stream &operator>>(bin_stream &s, pn532::rf_status &status);
   
       bin_stream &operator>>(bin_stream &s, pn532::gpio_status &gpio);
   
       bin_stream &operator>>(bin_stream &s, pn532::firmware_version &fw);
   
       bin_stream &operator>>(bin_stream &s, pn532::general_status &gs);
   
       bin_stream &operator>>(bin_stream &s, pn532::general_status_target &ts);
   
       bin_stream &operator>>(bin_stream &s, pn532::target_kbps106_typea &target);
   
       bin_stream &operator>>(bin_stream &s, pn532::target_kbps212_felica &target);
   
       bin_stream &operator>>(bin_stream &s, pn532::target_kbps424_felica &target);
   
       bin_stream &operator>>(bin_stream &s, pn532::target_kbps106_typeb &target);
   
       bin_stream &operator>>(bin_stream &s, pn532::target_kbps106_jewel_tag &target);
   
       bin_stream &operator>>(bin_stream &s, pn532::atr_res_info &atr_res);
   
       bin_stream &operator>>(bin_stream &s, std::pair<pn532::rf_status, pn532::atr_res_info> &status_atr_res);
   
       bin_stream &operator>>(bin_stream &s, pn532::bits::reg_antenna_detector &r);
   
       bin_stream &operator>>(bin_stream &s, pn532::jump_dep_psl &r);
   
       bin_stream &operator>>(bin_stream &s, pn532::general_status_sam &sams);
   
       bin_stream &operator>>(bin_stream &s, pn532::status_as_target &st);
   
       bin_stream &operator>>(bin_stream &s, pn532::activation_as_target_mode &mt);
   
       bin_stream &operator>>(bin_stream &s, pn532::activation_as_target &mt);
   #endif
   }// namespace mlab
   
   namespace pn532 {
   
       rf_status::operator bool() const {
           return error == internal_error_code::none;
       }
   
       bool gpio_status::operator[](std::pair<gpio_port, std::uint8_t> const &gpio_idx) const {
           switch (gpio_idx.first) {
               case gpio_port::p3:
                   return 0 != (_p3_mask & (1 << gpio_idx.second));
               case gpio_port::p7:
                   return 0 != (_p7_mask & (1 << gpio_idx.second));
               case gpio_port::i0i1:
                   return 0 != (_i0i1_mask & (1 << gpio_idx.second));
           }
       }
   
       mlab::bit_ref gpio_status::operator[](std::pair<gpio_port, std::uint8_t> const &gpio_idx) {
           static std::uint8_t _garbage = 0x00;
           switch (gpio_idx.first) {
               case gpio_port::p3:
                   return mlab::bit_ref{_p3_mask, gpio_idx.second, bits::gpio_p3_pin_mask};
               case gpio_port::p7:
                   return mlab::bit_ref{_p7_mask, gpio_idx.second, bits::gpio_p7_pin_mask};
               case gpio_port::i0i1:
                   return mlab::bit_ref{_i0i1_mask, gpio_idx.second, bits::gpio_i0i1_pin_mask};
           }
           return mlab::bit_ref{_garbage, gpio_idx.second, 0xff};
       }
   
       gpio_status::gpio_status(std::uint8_t p3_mask, std::uint8_t p7_mask, std::uint8_t i0i1_mask) : _p3_mask{p3_mask}, _p7_mask{p7_mask}, _i0i1_mask{i0i1_mask} {}
   
       inline std::uint8_t gpio_status::mask(gpio_port loc) const {
           switch (loc) {
               case gpio_port::p3:
                   return _p3_mask;
               case gpio_port::p7:
                   return _p7_mask;
               case gpio_port::i0i1:
                   return _i0i1_mask;
           }
           return 0x00;
       }
   
       void gpio_status::set_mask(gpio_port loc, std::uint8_t mask) {
           switch (loc) {
               case gpio_port::p3:
                   _p3_mask = mask & bits::gpio_p3_pin_mask;
                   break;
               case gpio_port::p7:
                   _p7_mask = mask & bits::gpio_p7_pin_mask;
                   break;
               case gpio_port::i0i1:
                   _i0i1_mask = mask & bits::gpio_i0i1_pin_mask;
                   break;
           }
       }
   
   }// namespace pn532
   
   namespace mlab {
       template <pn532::baudrate_modulation BrMd>
       bin_stream &operator>>(bin_stream &s, std::vector<pn532::target<BrMd>> &targets) {
           if (s.remaining() < 1) {
               PN532_LOGE("Parsing vector<target<%s>>: not enough data.", pn532::to_string(BrMd));
               s.set_bad();
               return s;
           }
           const auto num_targets = s.pop();
           if (num_targets > pn532::bits::max_num_targets) {
               PN532_LOGW("Parsing vector<target<%s>>: found %u targets, which is more than the number of supported targets %u.",
                          pn532::to_string(BrMd), num_targets, pn532::bits::max_num_targets);
           }
           targets.resize(num_targets);
           for (auto &target : targets) {
               if (not s.good()) {
                   break;
               }
               s >> target;
           }
           return s;
       }
   
       template <pn532::target_type Type>
       bin_stream &operator>>(bin_stream &s, pn532::poll_target<Type> &entry) {
           static constexpr pn532::baudrate_modulation BrMod = pn532::baudrate_modulation_of(Type);
           if constexpr (std::is_base_of_v<pn532::target<BrMod>, pn532::poll_target<Type>>) {
               s >> static_cast<pn532::target<BrMod> &>(entry);
           }
           if constexpr (std::is_base_of_v<pn532::poll_target_with_atr, pn532::poll_target<Type>>) {
               s >> static_cast<pn532::poll_target_with_atr &>(entry).atr_info;
           }
           return s;
       }
   
   }// namespace mlab
   
   #endif//PN532_DATA_HPP