.. _program_listing_file_libspookyaction_include_pn532_controller.hpp:

Program Listing for File controller.hpp
=======================================

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

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

.. code-block:: cpp

   //
   // Created by Pietro Saccardi on 20/12/2020.
   //
   
   #ifndef PN532_CONTROLLER_HPP
   #define PN532_CONTROLLER_HPP
   
   #include <mlab/result.hpp>
   #include <mutex>
   #include <pn532/bits.hpp>
   #include <pn532/channel.hpp>
   #include <pn532/data.hpp>
   #include <pn532/msg.hpp>
   
   namespace pn532 {
       using namespace std::chrono_literals;
       static constexpr ms default_timeout = 1s;
       static constexpr ms long_timeout = 3s;
       using namespace mlab_literals;
   
       class controller : public std::enable_shared_from_this<controller> {
           std::recursive_timed_mutex _mtx;
   
       public:
           static const std::vector<target_type> poll_all_targets;
   
           static constexpr auto max_supported_targets = bits::max_num_targets;
   
           explicit controller(std::shared_ptr<channel> chn);
   
           controller(controller const &) = delete;
   
           controller(controller &&) = delete;
   
           controller &operator=(controller const &) = delete;
   
           controller &operator=(controller &&) = delete;
   
           [[nodiscard]] result<bool> diagnose_rom(ms timeout = long_timeout);
   
           [[nodiscard]] result<bool> diagnose_ram(ms timeout = long_timeout);
   
           [[nodiscard]] result<bool> diagnose_attention_req_or_card_presence(ms timeout = long_timeout);
   
           [[nodiscard]] result<bool> diagnose_comm_line(ms timeout = long_timeout);
   
           [[nodiscard]] result<unsigned, unsigned> diagnose_poll_target(bool slow = true, bool fast = true, ms timeout = long_timeout);
   
           [[nodiscard]] result<> diagnose_echo_back(ms reply_delay, std::uint8_t tx_mode, std::uint8_t rx_mode, ms timeout = long_timeout);
   
           [[nodiscard]] result<bool> diagnose_self_antenna(low_current_thr low_threshold, high_current_thr high_threshold, ms timeout = long_timeout);
   
           [[nodiscard]] result<firmware_version> get_firmware_version(ms timeout = default_timeout);
   
           [[nodiscard]] result<general_status> get_general_status(ms timeout = default_timeout);
   
           [[nodiscard]] result<std::vector<uint8_t>> read_registers(std::vector<reg::addr> const &addresses, ms timeout = default_timeout);
   
           inline result<uint8_t> read_register(reg::addr const &addr, ms timeout = default_timeout);
   
           result<> write_registers(std::vector<std::pair<reg::addr, std::uint8_t>> const &addr_value_pairs, ms timeout = default_timeout);
   
           inline result<> write_register(reg::addr const &addr, std::uint8_t val, ms timeout = default_timeout);
   
           [[nodiscard]] result<gpio_status> read_gpio(ms timeout = default_timeout);
   
           result<> write_gpio(gpio_status const &status, bool write_p3 = true, bool write_p7 = true, ms timeout = default_timeout);
   
           result<> set_gpio_pin(gpio_port loc, std::uint8_t pin_idx, bool value, ms timeout = default_timeout);
   
           result<> set_serial_baud_rate(serial_baudrate br, ms timeout = default_timeout);
   
           result<> sam_configuration(sam_mode mode, ms sam_timeout, bool controller_drives_irq = true, ms timeout = default_timeout);
   
           result<> set_parameters(parameters const &parms, ms timeout = default_timeout);
   
           result<rf_status> power_down(std::vector<wakeup_source> const &wakeup_sources, bool generate_irq, ms timeout = default_timeout);
           result<rf_status> power_down(std::vector<wakeup_source> const &wakeup_sources, ms timeout = default_timeout);
           [[nodiscard]] bool init_and_test();
           result<> rf_configuration_field(bool auto_rfca, bool rf_on, ms timeout = default_timeout);
   
           result<> rf_configuration_timings(rf_timeout atr_res_timeout = rf_timeout::ms_102_4, rf_timeout retry_timeout = rf_timeout::ms_51_2, ms timeout = default_timeout);
   
           result<> rf_configuration_retries(infbyte comm_retries = 0_b, ms timeout = default_timeout);
   
           result<> rf_configuration_retries(infbyte atr_retries, infbyte psl_retries, infbyte passive_activation_retries = infty, ms timeout = default_timeout);
   
           result<> rf_configuration_analog_106kbps_typea(reg::ciu_106kbps_typea const &config, ms timeout = default_timeout);
   
           result<> rf_configuration_analog_212_424kbps(reg::ciu_212_424kbps const &config, ms timeout = default_timeout);
   
           result<> rf_configuration_analog_typeb(reg::ciu_typeb const &config, ms timeout = default_timeout);
   
           result<> rf_configuration_analog_iso_iec_14443_4(reg::ciu_iso_iec_14443_4 const &config, ms timeout = default_timeout);
   
           result<> rf_regulation_test(rf_test_mode mode, ms timeout = default_timeout);
   
           template <class T, class = typename std::enable_if<not std::is_same_v<bin_data, typename std::decay_t<T>::type>>::type>
           [[nodiscard]] result<rf_status, bin_data> initiator_data_exchange(std::uint8_t target_logical_index, T &&data, ms timeout = default_timeout);
   
           [[nodiscard]] result<rf_status, bin_data> initiator_data_exchange(std::uint8_t target_logical_index, bin_data const &data, ms timeout = default_timeout);
   
           result<rf_status> initiator_select(std::uint8_t target_logical_index, ms timeout = default_timeout);
   
           result<rf_status> initiator_deselect(std::uint8_t target_logical_index, ms timeout = default_timeout);
   
           result<rf_status> initiator_release(std::uint8_t target_logical_index, ms timeout = default_timeout);
   
           result<rf_status> initiator_psl(std::uint8_t target_logical_index, baudrate in_to_trg, baudrate trg_to_in, ms timeout = default_timeout);
   
           [[nodiscard]] result<std::vector<target_kbps106_typea>> initiator_list_passive_kbps106_typea(std::uint8_t max_targets = max_supported_targets, ms timeout = long_timeout);
   
           [[nodiscard]] result<std::vector<target_kbps106_typea>> initiator_list_passive_kbps106_typea(nfcid_1t uid, std::uint8_t max_targets = 1, ms timeout = long_timeout);
           [[nodiscard]] result<std::vector<target_kbps106_typea>> initiator_list_passive_kbps106_typea(nfcid_2t uid, std::uint8_t max_targets = 1, ms timeout = long_timeout);
           [[nodiscard]] result<std::vector<target_kbps106_typea>> initiator_list_passive_kbps106_typea(nfcid_3t uid, std::uint8_t max_targets = 1, ms timeout = long_timeout);
   
           [[nodiscard]] result<std::vector<target_kbps106_typeb>> initiator_list_passive_kbps106_typeb(
                   std::uint8_t application_family_id, polling_method method = polling_method::timeslot,
                   std::uint8_t max_targets = max_supported_targets, ms timeout = long_timeout);
   
           [[nodiscard]] result<std::vector<target_kbps212_felica>> initiator_list_passive_kbps212_felica(
                   std::array<std::uint8_t, 5> const &payload, std::uint8_t max_targets = max_supported_targets,
                   ms timeout = long_timeout);
   
           [[nodiscard]] result<std::vector<target_kbps424_felica>> initiator_list_passive_kbps424_felica(
                   std::array<std::uint8_t, 5> const &payload, std::uint8_t max_targets = max_supported_targets,
                   ms timeout = long_timeout);
   
           [[nodiscard]] result<std::vector<target_kbps106_jewel_tag>> initiator_list_passive_kbps106_jewel_tag(ms timeout = long_timeout);
   
           result<rf_status, atr_res_info> initiator_activate_target(std::uint8_t target_logical_index, nfcid_3t const &nfcid, std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<rf_status, atr_res_info> initiator_activate_target(std::uint8_t target_logical_index, std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<rf_status, atr_res_info> initiator_activate_target(std::uint8_t target_logical_index, nfcid_3t const &nfcid, ms timeout = default_timeout);
           result<rf_status, atr_res_info> initiator_activate_target(std::uint8_t target_logical_index, ms timeout = default_timeout);
           [[nodiscard]] result<std::vector<any_poll_target>> initiator_auto_poll(
                   std::vector<target_type> const &types_to_poll = poll_all_targets,
                   infbyte polls_per_type = 3_b, poll_period period = poll_period::ms_150, ms timeout = long_timeout);
   
           [[nodiscard]] result<rf_status, bin_data> initiator_communicate_through(bin_data raw_data, ms timeout = default_timeout);
   
           result<jump_dep_psl> initiator_jump_for_dep_active(baudrate speed, nfcid_3t const &nfcid, std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_dep_active(baudrate speed, std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_dep_active(baudrate speed, nfcid_3t const &nfcid, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_dep_active(baudrate speed, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_dep_passive_106kbps(nfcid_1t target_id, nfcid_3t const &nfcid, std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_dep_passive_106kbps(nfcid_1t target_id, std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_dep_passive_106kbps(nfcid_1t target_id, nfcid_3t const &nfcid, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_dep_passive_106kbps(nfcid_1t target_id, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_dep_passive_106kbps(nfcid_3t const &nfcid, std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_dep_passive_106kbps(std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_dep_passive_106kbps(nfcid_3t const &nfcid, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_dep_passive_106kbps(ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_dep_passive_212kbps(std::array<std::uint8_t, 5> const &payload, std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_dep_passive_212kbps(std::array<std::uint8_t, 5> const &payload, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_dep_passive_424kbps(std::array<std::uint8_t, 5> const &payload, std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_dep_passive_424kbps(std::array<std::uint8_t, 5> const &payload, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_psl_active(baudrate speed, nfcid_3t const &nfcid, std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_psl_active(baudrate speed, std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_psl_active(baudrate speed, nfcid_3t const &nfcid, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_psl_active(baudrate speed, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_psl_passive_106kbps(nfcid_3t const &nfcid, std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_psl_passive_106kbps(std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_psl_passive_106kbps(nfcid_3t const &nfcid, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_psl_passive_106kbps(ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_psl_passive_106kbps(nfcid_1t target_id, nfcid_3t const &nfcid, std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_psl_passive_106kbps(nfcid_1t target_id, std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_psl_passive_106kbps(nfcid_1t target_id, nfcid_3t const &nfcid, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_psl_passive_106kbps(nfcid_1t target_id, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_psl_passive_212kbps(std::array<std::uint8_t, 5> const &payload, std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_psl_passive_212kbps(std::array<std::uint8_t, 5> const &payload, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_psl_passive_424kbps(std::array<std::uint8_t, 5> const &payload, std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
           result<jump_dep_psl> initiator_jump_for_psl_passive_424kbps(std::array<std::uint8_t, 5> const &payload, ms timeout = default_timeout);
           [[nodiscard]] result<status_as_target> target_get_target_status(ms timeout = default_timeout);
   
           [[nodiscard]] result<activation_as_target> target_init_as_target(
                   bool picc_only, bool dep_only, bool passive_only, mifare_params const &mifare,
                   felica_params const &felica, nfcid_3t const &nfcid,
                   std::vector<std::uint8_t> const &general_info = {},
                   std::vector<std::uint8_t> const &historical_bytes = {}, ms timeout = default_timeout);
   
           result<rf_status> target_set_general_bytes(std::vector<std::uint8_t> const &general_info, ms timeout = default_timeout);
   
           [[nodiscard]] result<rf_status, bin_data> target_get_data(ms timeout = default_timeout);
   
           result<rf_status> target_set_data(std::vector<std::uint8_t> const &data, ms timeout = default_timeout);
   
           result<rf_status> target_set_metadata(std::vector<std::uint8_t> const &data, ms timeout = default_timeout);
   
           [[nodiscard]] result<rf_status, bin_data> target_get_initiator_command(ms timeout = default_timeout);
   
           result<rf_status> target_response_to_initiator(std::vector<std::uint8_t> const &data, ms timeout = default_timeout);
       private:
           std::shared_ptr<channel> _channel;
   
           [[nodiscard]] inline channel &chn() const;
   
           [[nodiscard]] static std::uint8_t get_target(command_code cmd, std::uint8_t target_logical_index, bool expect_more_data);
   
           template <baudrate_modulation BrMd>
           result<std::vector<target<BrMd>>> initiator_list_passive(std::uint8_t max_targets, bin_data const &initiator_data, ms timeout);
       };
   
   }// namespace pn532
   
   
   namespace pn532 {
   
       channel &controller::chn() const { return *_channel; }
   
       result<uint8_t> controller::read_register(reg::addr const &addr, ms timeout) {
           if (const auto res_cmd = read_registers({addr}, timeout); res_cmd) {
               return res_cmd->at(0);
           } else {
               return res_cmd.error();
           }
       }
   
       result<> controller::write_register(reg::addr const &addr, std::uint8_t val, ms timeout) {
           return write_registers({{addr, val}}, timeout);
       }
   
       template <class T, class>
       result<rf_status, bin_data> controller::initiator_data_exchange(std::uint8_t target_logical_index, T &&data, ms timeout) {
           static bin_data buffer{};
           buffer.clear();
           buffer << std::forward<T>(data);
           return initiator_data_exchange(target_logical_index, buffer, timeout);
       }
   
   }// namespace pn532
   
   
   #endif//PN532_CONTROLLER_HPP