Gen2-UHF-RFID-Reader学习（六）reader

已于 2022-06-18 17:49:24 修改
阅读量1k 收藏
点赞数 2
分类专栏： EPC协议学习 文章标签： c++
于 2021-06-29 09:26:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/I_Found/article/details/118314065
版权

本篇博客用于记录学习和使用github程序包Gen2-UHF-RFID-Reader的过程。出错的地方还望大家指正。
使用平台：ubuntu16.04      UHD3.14.0.HEAD-0-g6875d061     gnuradio3.7.10.1      USRP N210（SBX子板）
本篇详细分析reader_impl.cc文件。
reader模块功能：判断系统所处盘存阶段，生成对应命令或信号，并对基带信号进行PIE编码输出。

    reader::sptr
    reader::make(int sample_rate, int dac_rate)
    {
      return gnuradio::get_initial_sptr
        (new reader_impl(sample_rate,dac_rate));
    }

reader模块的重要参数为sample_rate，dac_rate。

    reader_impl::reader_impl(int sample_rate, int dac_rate)
      : gr::block("reader",
              gr::io_signature::make( 1, 1, sizeof(float)),
              gr::io_signature::make( 1, 1, sizeof(float)))
    {

      GR_LOG_INFO(d_logger, "Block initialized");

      sample_d = 1.0/dac_rate * pow(10,6);

      // Number of samples for transmitting

      n_data0_s = 2 * PW_D / sample_d;
      n_data1_s = 4 * PW_D / sample_d;
      n_pw_s    = PW_D    / sample_d;
      n_cw_s    = CW_D    / sample_d;
      n_delim_s = DELIM_D / sample_d;
      n_trcal_s = TRCAL_D / sample_d;

      GR_LOG_INFO(d_logger, "Number of samples data 0 : " << n_data0_s);
      GR_LOG_INFO(d_logger, "Number of samples data 1 : " << n_data1_s);
      GR_LOG_INFO(d_logger, "Number of samples cw : "     << n_cw_s);
      GR_LOG_INFO(d_logger, "Number of samples delim : "  << n_delim_s);
      GR_LOG_INFO(d_logger, "Number of slots : "          << std::pow(2,FIXED_Q));

      // CW waveforms of different sizes
      n_cwquery_s   = (T1_D+T2_D+RN16_D)/sample_d;     //RN16
      n_cwack_s     = (3*T1_D+T2_D+EPC_D)/sample_d;    //EPC   if it is longer than nominal it wont cause tags to change inventoried flag
      n_p_down_s     = (P_DOWN_D)/sample_d;  

      p_down.resize(n_p_down_s);        // Power down samples
      cw_query.resize(n_cwquery_s);      // Sent after query/query rep
      cw_ack.resize(n_cwack_s);          // Sent after ack

      std::fill_n(cw_query.begin(), cw_query.size(), 1);
      std::fill_n(cw_ack.begin(), cw_ack.size(), 1);

      GR_LOG_INFO(d_logger, "Carrier wave after a query transmission in samples : "     << n_cwquery_s);
      GR_LOG_INFO(d_logger, "Carrier wave after ACK transmission in samples : "        << n_cwack_s);

      // Construct vectors (resize() default initialization is zero)
      data_0.resize(n_data0_s);
      data_1.resize(n_data1_s);
      cw.resize(n_cw_s);
      delim.resize(n_delim_s);
      rtcal.resize(n_data0_s + n_data1_s);
      trcal.resize(n_trcal_s);

      // Fill vectors with data，利用PIE编码进行编码填充
      std::fill_n(data_0.begin(), data_0.size()/2, 1);
      std::fill_n(data_1.begin(), 3*data_1.size()/4, 1);
      std::fill_n(cw.begin(), cw.size(), 1);
      std::fill_n(rtcal.begin(), rtcal.size() - n_pw_s, 1); // RTcal
      std::fill_n(trcal.begin(), trcal.size() - n_pw_s, 1); // TRcal

      // create preamble
      preamble.insert( preamble.end(), delim.begin(), delim.end() );
      preamble.insert( preamble.end(), data_0.begin(), data_0.end() );
      preamble.insert( preamble.end(), rtcal.begin(), rtcal.end() );
      preamble.insert( preamble.end(), trcal.begin(), trcal.end() );

      // create framesync
      frame_sync.insert( frame_sync.end(), delim.begin() , delim.end() );
      frame_sync.insert( frame_sync.end(), data_0.begin(), data_0.end() );
      frame_sync.insert( frame_sync.end(), rtcal.begin() , rtcal.end() );
      
      // create query rep
      query_rep.insert( query_rep.end(), frame_sync.begin(), frame_sync.end());
      query_rep.insert( query_rep.end(), data_0.begin(), data_0.end() );
      query_rep.insert( query_rep.end(), data_0.begin(), data_0.end() );
      query_rep.insert( query_rep.end(), data_0.begin(), data_0.end() );
      query_rep.insert( query_rep.end(), data_0.begin(), data_0.end() );

      // create nak
      nak.insert( nak.end(), frame_sync.begin(), frame_sync.end());
      nak.insert( nak.end(), data_1.begin(), data_1.end() );
      nak.insert( nak.end(), data_1.begin(), data_1.end() );
      nak.insert( nak.end(), data_0.begin(), data_0.end() );
      nak.insert( nak.end(), data_0.begin(), data_0.end() );
      nak.insert( nak.end(), data_0.begin(), data_0.end() );
      nak.insert( nak.end(), data_0.begin(), data_0.end() );
      nak.insert( nak.end(), data_0.begin(), data_0.end() );
      nak.insert( nak.end(), data_0.begin(), data_0.end() );

      gen_query_bits();
      gen_query_adjust_bits();
    }

reader模块有一个输入端口，一个输出端口。构造函数中计算了数字“0”、数字“1”、半个Tari、连续波CW、前导码、TRcal、标签响应RN16、标签响应EPC、掉电时的采样点数，利用PIE编码对“0”、“1”、CW、RTcal、TRcal进行编码，并对前导码、帧同步码、query_rep、nak命令进行构造，以便后续使用。

   void reader_impl::gen_query_bits()
    {
      int num_ones = 0, num_zeros = 0;

      query_bits.resize(0);
      query_bits.insert(query_bits.end(), &QUERY_CODE[0], &QUERY_CODE[4]);
      query_bits.push_back(DR);
      query_bits.insert(query_bits.end(), &M[0], &M[2]);
      query_bits.push_back(TREXT);
      query_bits.insert(query_bits.end(), &SEL[0], &SEL[2]);
      query_bits.insert(query_bits.end(), &SESSION[0], &SESSION[2]);
      query_bits.push_back(TARGET);
    
      query_bits.insert(query_bits.end(), &Q_VALUE[FIXED_Q][0], &Q_VALUE[FIXED_Q][4]);
      crc_append(query_bits);
    }

gen_query_bits函数对query字段进行构造填充，关于query字段的解释详见Gen2-UHF-RFID-Reader学习（二）。

    void reader_impl::gen_ack_bits(const float * in)
    {
      ack_bits.resize(0);
      ack_bits.insert(ack_bits.end(), &ACK_CODE[0], &ACK_CODE[2]);
      ack_bits.insert(ack_bits.end(), &in[0], &in[16]);
    }
  
    void reader_impl::gen_query_adjust_bits()
    {
      query_adjust_bits.resize(0);
      query_adjust_bits.insert(query_adjust_bits.end(), &QADJ_CODE[0], &QADJ_CODE[4]);
      query_adjust_bits.insert(query_adjust_bits.end(), &SESSION[0], &SESSION[2]);
      query_adjust_bits.insert(query_adjust_bits.end(), &Q_UPDN[1][0], &Q_UPDN[1][3]);
    }

gen_ack_bits函数对ack命令字段进行构造填充。gen_query_adjust_bits函数对query_adjust命令字段进行构造填充。

    reader_impl::~reader_impl()
    {

    }
	void
		reader_impl::forecast(int noutput_items, gr_vector_int &ninput_items_required)
	{
		ninput_items_required[0] = 0;
	}

析构函数没有内容。forecast函数为自带函数，无需变更。

    int reader_impl::print_results()
    {
      //std::cout << "count: " << get_count() << std::endl;
      
      std::cout << "\n --------------------------" << std::endl;
      std::cout << "| Number of queries/queryreps sent : " << reader_state->reader_stats.n_queries_sent - 1 << std::endl;
      std::cout << "| Current Inventory round : "          << reader_state->reader_stats.cur_inventory_round << std::endl;
      std::cout << " --------------------------"            << std::endl;

      std::cout << "| Correctly decoded EPC : "  <<  reader_state->reader_stats.n_epc_correct     << std::endl;
      std::cout << "| Number of unique tags : "  <<  reader_state->reader_stats.tag_reads.size() << std::endl;

      std::map<std::string,int>::iterator it;

      for(it = reader_state->reader_stats.tag_reads.begin(); it != reader_state->reader_stats.tag_reads.end(); it++) 
      {
        std::cout <<  "| Tag ID : ";
        for(int i = 0; i < it->first.size(); ++i)
        {
          std::cout << it->first[i];
          if(i%4 == 3 && i != it->first.size()-1)
             std::cout << "-";
        } 
        std::cout << std::endl;
        std::cout << "Num of reads : " << std::dec << it->second << std::endl;
      }

      std::cout << " --------------------------" << std::endl;
      std::cout << reader_state->reader_stats.n_queries_sent << std::endl;
      return 1;
    }

print_results函数对统计结果进行输出，这一般在系统结束时才允许，不能达到实时显示读取情况，这也是该系统的一个缺陷。

   int
    reader_impl::general_work (int noutput_items,
                       gr_vector_int &ninput_items,
                       gr_vector_const_void_star &input_items,
                       gr_vector_void_star &output_items)
    {

      const float *in = (const float *) input_items[0];
      float *out =  (float*) output_items[0];
      std::vector<float> out_message; 
      int n_output;
      int consumed = 0;
      int written = 0;

      consumed = ninput_items[0];
  
      switch (reader_state->gen2_logic_status)
      {
        case START:
          GR_LOG_INFO(d_debug_logger, "START");

          memcpy(&out[written], &cw_ack[0], sizeof(float) * cw_ack.size() );
          written += cw_ack.size();
          reader_state->gen2_logic_status = SEND_QUERY;    
          break;

        case POWER_DOWN:
          GR_LOG_INFO(d_debug_logger, "POWER DOWN");
          memcpy(&out[written], &p_down[0], sizeof(float) * p_down.size() );
          written += p_down.size();
          reader_state->gen2_logic_status = START;    
          break;

        case SEND_NAK_QR:
          GR_LOG_INFO(d_debug_logger, "SEND NAK");
          memcpy(&out[written], &nak[0], sizeof(float) * nak.size() );
          written += nak.size();
          memcpy(&out[written], &cw[0], sizeof(float) * cw.size() );
          written+=cw.size();
          reader_state->gen2_logic_status = SEND_QUERY_REP;    
          break;

        case SEND_NAK_Q:
          GR_LOG_INFO(d_debug_logger, "SEND NAK");
          memcpy(&out[written], &nak[0], sizeof(float) * nak.size() );
          written += nak.size();
          memcpy(&out[written], &cw[0], sizeof(float) * cw.size() );
          written+=cw.size();
          reader_state->gen2_logic_status = SEND_QUERY;    
          break;

        case SEND_QUERY:

          /*if (reader_state->reader_stats.n_queries_sent % 10 == 0)
          {
            std::cout << "Running " << std::endl;
          }*/
          //std::cout << "count:" << get_count() << std::endl; 
          GR_LOG_INFO(d_debug_logger, "QUERY");
          GR_LOG_INFO(d_debug_logger, "INVENTORY ROUND : " << reader_state->reader_stats.cur_inventory_round << " SLOT NUMBER : " << reader_state->reader_stats.cur_slot_number);

          reader_state->reader_stats.n_queries_sent +=1; 
          // Controls the other two blocks
          reader_state->decoder_status = DECODER_DECODE_RN16;
          reader_state->gate_status    = GATE_SEEK_RN16;

          memcpy(&out[written], &preamble[0], sizeof(float) * preamble.size() );
          written+=preamble.size();
   
          for(int i = 0; i < query_bits.size(); i++)
          {
            if(query_bits[i] == 1)
            {
              memcpy(&out[written], &data_1[0], sizeof(float) * data_1.size() );
              written+=data_1.size();
            }
            else
            {
              memcpy(&out[written], &data_0[0], sizeof(float) * data_0.size() );
              written+=data_0.size();
            }
          }
          // Send CW for RN16
          memcpy(&out[written], &cw_query[0], sizeof(float) * cw_query.size() );
          written+=cw_query.size();

          // Return to IDLE
          reader_state->gen2_logic_status = IDLE;      
          break;

        case SEND_ACK:
          GR_LOG_INFO(d_debug_logger, "SEND ACK");
          if (ninput_items[0] == RN16_BITS - 1)
          {
            // Controls the other two blocks
            reader_state->decoder_status = DECODER_DECODE_EPC;
            reader_state->gate_status    = GATE_SEEK_EPC;

            gen_ack_bits(in);
          
            // Send FrameSync
            memcpy(&out[written], &frame_sync[0], sizeof(float) * frame_sync.size() );
            written += frame_sync.size();

            for(int i = 0; i < ack_bits.size(); i++)
            {
              if(ack_bits[i] == 1)
              {
                memcpy(&out[written], &data_1[0], sizeof(float) * data_1.size() );
                written += data_1.size();
              }
              else  
              {
                memcpy(&out[written], &data_0[0], sizeof(float) * data_0.size() );
                written += data_0.size();
              }
            }
             consumed = ninput_items[0];
            reader_state->gen2_logic_status = SEND_CW; 
          }
          break;

        case SEND_CW:
          GR_LOG_INFO(d_debug_logger, "SEND CW");
          memcpy(&out[written], &cw_ack[0], sizeof(float) * cw_ack.size() );
          written += cw_ack.size();
          reader_state->gen2_logic_status = IDLE;      // Return to IDLE
          break;

        case SEND_QUERY_REP:
          GR_LOG_INFO(d_debug_logger, "SEND QUERY_REP");
          GR_LOG_INFO(d_debug_logger, "INVENTORY ROUND : " << reader_state->reader_stats.cur_inventory_round << " SLOT NUMBER : " << reader_state->reader_stats.cur_slot_number);
          // Controls the other two blocks
          reader_state->decoder_status = DECODER_DECODE_RN16;
          reader_state->gate_status    = GATE_SEEK_RN16;
          reader_state->reader_stats.n_queries_sent +=1;  
          memcpy(&out[written], &query_rep[0], sizeof(float) * query_rep.size() );
          written += query_rep.size();

          memcpy(&out[written], &cw_query[0], sizeof(float) * cw_query.size());
          written+=cw_query.size();

          reader_state->gen2_logic_status = IDLE;    // Return to IDLE
          break;
      
        case SEND_QUERY_ADJUST:
          GR_LOG_INFO(d_debug_logger, "SEND QUERY_ADJUST");
          // Controls the other two blocks
          reader_state->decoder_status = DECODER_DECODE_RN16;
          reader_state->gate_status    = GATE_SEEK_RN16;
          reader_state->reader_stats.n_queries_sent +=1;  
          memcpy(&out[written], &frame_sync[0], sizeof(float) * frame_sync.size() );
          written += frame_sync.size();

          for(int i = 0; i < query_adjust_bits.size(); i++)
          {
            if(query_adjust_bits[i] == 1)
            {
              memcpy(&out[written], &data_1[0], sizeof(float) * data_1.size() );
              written+=data_1.size();
            }
            else
            {
              memcpy(&out[written], &data_0[0], sizeof(float) * data_0.size() );
              written+=data_0.size();
            }
          }
          memcpy(&out[written], &cw_query[0], sizeof(float) * cw_query.size());
          written+=cw_query.size();
          reader_state->gen2_logic_status = IDLE;    // Return to IDLE
          break;

        default:
          // IDLE
          break;
      }
      consume_each (consumed);
      return  written;
    }

模块的核心工作，其逻辑可用下述流程图表示：
在这里插入图片描述

    /* Function adapted from https://www.cgran.org/wiki/Gen2 */
    void reader_impl::crc_append(std::vector<float> & q)
    {
       int crc[] = {1,0,0,1,0};

      for(int i = 0; i < 17; i++)
      {
        int tmp[] = {0,0,0,0,0};
        tmp[4] = crc[3];
        if(crc[4] == 1)
        {
          if (q[i] == 1)
          {
            tmp[0] = 0;
            tmp[1] = crc[0];
            tmp[2] = crc[1];
            tmp[3] = crc[2];
          }
          else
          {
            tmp[0] = 1;
            tmp[1] = crc[0];
            tmp[2] = crc[1];
            if(crc[2] == 1)
            {
              tmp[3] = 0;
            }
            else
            {
              tmp[3] = 1;
            }
          }
        }
        else
        {
          if (q[i] == 1)
          {
            tmp[0] = 1;
            tmp[1] = crc[0];
            tmp[2] = crc[1];
            if(crc[2] == 1)
            {
              tmp[3] = 0;
            }
            else
            {
              tmp[3] = 1;
            }
          }
          else
          {
            tmp[0] = 0;
            tmp[1] = crc[0];
            tmp[2] = crc[1];
            tmp[3] = crc[2];
          }
        }
        memcpy(crc, tmp, 5*sizeof(float));
      }
      for (int i = 4; i >= 0; i--)
        q.push_back(crc[i]);
    }

crc_append函数为CRC-16的构造过程。

guess_only
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
rfid reader 控制软件
02-03
南京瑞福读写器 控制软件 串口通讯 开发工具 vc
matlab匹配滤波代码-Gen2-UHF-RFID-Reader-1:40kHz，带有USRPN210
05-24
matlab匹配滤波代码Gen2 UHF RFID读取器 源自此存储库 这是Gen2 UHF RFID读取器。 它能够识别具有FM0线路编码和40kHz数据速率（BLF）的商业Gen2 RFID标签，并提取其EPC消息。 它需要USRPN200，并已通过单个前端卡（RFX900）进行了测试。 由Nikos Kargas在其硕士学位论文的背景下开发，技术大学电子与计算机工程学院。 克里特岛。 该项目最初基于RFID Gen2阅读器，该阅读器可从以下网站获得（以前，供稿人：Michael Buettner）。 为了使其与最新版本的GNU Radio，UHD以及USRPN200兼容，我决定从头开始编写Gen2 Reader。 阅读器借鉴了Buettner开发的软件中的元素，即数据流：Gate-> Decoder-> Reader，以及有关检测阅读器命令的概念。 CRC计算和检查功能也改编自。 已实现的GNU Radio Blocks： Gate：负责阅读器命令检测。 标签解码器：负责帧同步，信道估计，符号周期估计和检测。 Reader（Gen2逻辑）：创建/发送阅读器命令。 安装 安装log
Gen2-UHF-RFID-Reader学习（一）概览
I_Guess的博客
06-26 2707
本篇博客用于记录学习和使用Gen2-UHF-RFID-Reader的过程。 使用平台：ubuntu16.04 UHD3.14.0.HEAD-0-g6875d061 gnuradio3.7.10.1 USRP N210（SBX子板）
Gen2-UHF-RFID-Reader学习（七）reader.py
I_Guess的博客
06-29 929
reader.py
Gen2-UHF-RFID-Reader学习（八）
I_Guess的博客
06-30 964
github程序包Gen2-UHF-RFID-Reader包使用记录
RFID基本理论与操作实验
深大cs课程实验及学习笔记，ccfcsp部分真题，华为题库
12-14 2797
1.超高频RFID标签的寻卡操作。 2.超高频RFID标签的读写操作。 3.超高频RFID标签多张卡读取时的防冲突机制。
UHF_RFID_Reader_Demo_标签识别_UHFRFID_UHFReaderDemo_uhfreader软件_DEMO
09-30
电子标签读写程序，结合电子标签识别模块能快速读取标签的信息，还能写信息到标签内。
超高频（UHF）RFID reader的原理架构
weixin_43970554的博客
10-28 4621
1.目前几种超高频 RFID reader芯片对比 由上表可以看出英频杰的R2000在性能上具有较强的优势，缺点是耗电高和价格高。韩国Phychips和国产MagicRF公司的产品差异不大，价格方面国产的更有优势。在一些手持设备，对读取距离要求不苛刻，对功耗很在意的应用场景可以考虑采用国产芯片。 2.基于M100的UHF RFID reader的原理框架 以上就是基于MagicRF的M100设计的UHF RFID 读卡器的原理框图。M100内部集成了一个由256个字节的8位的8051MCU，但没有fla
电子标签读写器UHFReader18 2.1.zip
05-23
电子标签读写器UHFReader18演示了对ISO18000-6B,6C标准的RFID条码进行操作的所有细节。主要功能：读写器参数设置界面操作1．打开端口2．读写器参数设置3．工作模式参数设置必要的知识点1．EPCC1G2标签存储器2．18000-6B标签3.数据显示（EPC号、UID号、密码、存储数据都是16进制显示） EPCC1-G2Test界面操作（打开端口之后）1．询查标签（需要选择标签的操作都需要先询查标签）2．读写数据、块擦除3．修改密码4．写EPC号（不需要询查标签）5．设置读写保护状态6．读保护7．EAS报警8．锁定用户区数据块锁（永久锁定）9．销毁标签（永久毁灭）10．EPC掩模18000-6BTest界面操作（打开端口之后）1．询查标签2．读写数据/字节块永久写保护标签频点分析界面操作（打开端口之后） 注意事项：1、开发环境为Visual Studio2010，使用.net2.0开发。
RFID_UHF_VC.rar_485通讯_RFID-reader_Vc_rfid matlab_条码
07-14
RFID_VC++6.0源码_RFID读写 提供了RFID的开发源码，用VC编的，展示RFID卡如何加密，如何自毁。串口通讯支持RS-232(RS232)，RS-485(RS485)...支持ISO18000和EPC_GEN2等类型的RFID卡。 VC++6.0的工作空间是“t1121.dsw”
RFID(UHFReader)demo.rar
03-21
y源码参考，欢迎下载
rfid通用驱动程序
06-05
rfid读卡器通用驱动程序，可为任意型号RFID读卡器驱动。
RFIDReaderSDK
11-13
RFIDReaderSDK专用RFID开发接口说明
YowoRFIDreader.jar
03-06
有我科技Android SDK 所需的资源jar包，直接引入项目可以供使用。官方使用方法说明和api文档连接：http://www.youwokeji.com.cn/AndroidReader/
uhf-Reader演示软件
最新发布
09-18
6. **兼容性**：UHF-Reader演示软件应能兼容多种UHF RFID标准，如EPC Global Class 1 Generation 2 (Gen2) 或ISO/IEC 18000-63，确保与不同厂商的读写器和标签兼容。 7. **参数调整**：用户可以通过软件调整读写器...
行业分类-设备装置-RFID读写器、RFID系统及通信方法.zip
08-22
RFID系统通常由三部分组成：RFID标签（Tag）、RFID读写器（Reader）和后端处理系统。在“行业分类-设备装置-RFID读写器、RFID系统及通信方法”这个主题中，我们将深入探讨这些关键组件以及它们在不同领域的应用和...
EPC 协议--EPC_Class1_Gen2_UHF_RFID_Protocol
06-09
EPC协议，全称为Electronic Product Code（电子产品代码）协议，是一种在UHF频段（Ultra High Frequency）下工作的RFID（无线频率识别）通信标准。EPC Class 1 Generation 2（EPC C1G2）是这个协议的最新版本，它在...
android串口rfid开发板,RfidReader - 源码下载|通讯/手机编程|串口编程|源代码 - 源码中国...
weixin_28192383的博客
05-27 307
RfidReader\.classpath..........\.project..........\.settings\org.eclipse.jdt.core.prefs..........\AndroidManifest.xml..........\bin\AndroidManifest.xml..........\...\classes\com\flx\rfidreader\activit...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值