解决GNU Radio+USRP实现OFDM收发在接收端存在误码问题

/*
	函数功能：在信号处理或数据流处理程序中寻找触发信号的函数
*/
int header_payload_demux_impl::find_trigger_signal(int skip_items,
                                                   int max_rel_offset,
                                                   uint64_t base_offset,
                                                   const unsigned char* in_trigger)
{
/*
	参数说明：
	skip_items：开始搜索之前要跳过的项目数量
	max_rel_offset：最大的相对偏移量，即在这个范围内寻找触发信号
	base_offset：基准偏移量，是搜索的起始点
	in_trigger：指向触发信号数据的指针
*/
    int rel_offset = max_rel_offset;	// 初始化为最大相对偏移量，用来存储找到的触发信号的相对位置

	/*如果最大相对偏移量小于要跳过的项目数，直接返回rel_offset。
    这意味着没有足够的数据来进行搜索，所以函数提前结束。*/
    if (max_rel_offset < skip_items) {
        return rel_offset;
    }
	
    if (in_trigger) {	// 如果 in_trigger 不是空指针，即有触发信号数据提供进行搜索。
    	/*
    		这里使用了一个for循环从skip_items开始，一直到max_rel_offset，遍历触发信号数据。
    	*/
        for (int i = skip_items; i < max_rel_offset; i++) {
			/*
				如果在某个位置i找到触发信号（if (in_trigger[i])），则更新rel_offset为这个位置，
				并跳出循环。这表示找到了触发信号的第一个实例。
			*/
            if (in_trigger[i]) {
                rel_offset = i;
                break;
            }
        }
    }
    if (d_uses_trigger_tag) {	// 如果类的成员变量d_uses_trigger_tag为真，表示使用了触发标签进行搜索
        std::vector<tag_t> tags;	// 用来存储找到的标签
        get_tags_in_range(tags,	 // 从输入数据端口（PORT_INPUTDATA）中获取一个范围内的标签，并把这些标签存储到tags中
                          PORT_INPUTDATA,
                          base_offset + skip_items,
                          base_offset + max_rel_offset,
                          d_trigger_tag_key);
		/*
			如果找到了标签，则按照偏移量对它们进行排序。
			取排序后的第一个标签的相对偏移量（相对于base_offset），并与当前的rel_offset比较。如果找到的标签偏移量更小，则更新rel_offset为该标签偏移量。
		*/
        if (!tags.empty()) {
            std::sort(tags.begin(), tags.end(), tag_t::offset_compare);
            const int tag_rel_offset = tags[0].offset - base_offset;
            if (tag_rel_offset < rel_offset) {
                rel_offset = tag_rel_offset;
            }
        }
    }
    return rel_offset;	// 即找到的触发信号的相对位置（如果找到的话），或者是最大相对偏移量（如果没有找到触发信号）
} /* find_trigger_signal() */

int header_payload_demux_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 unsigned char* in = (const unsigned char*)input_items[PORT_INPUTDATA];
    unsigned char* out_header = (unsigned char*)output_items[PORT_HEADER];
    unsigned char* out_payload = (unsigned char*)output_items[PORT_PAYLOAD];

    const int n_input_items = (ninput_items.size() == 2)
                                  ? std::min(ninput_items[0], ninput_items[1])
                                  : ninput_items[0];
    // Items read going into general_work()
    const uint64_t n_items_read_base = nitems_read(PORT_INPUTDATA);
    // Items read during this call to general_work()
    int n_items_read = 0;

#define CONSUME_ITEMS(items_to_consume)                                         \
    update_special_tags(n_items_read_base + n_items_read,                       \
                        n_items_read_base + n_items_read + (items_to_consume)); \
    consume_each(items_to_consume);                                             \
    n_items_read += (items_to_consume);                                         \
    in += (items_to_consume)*d_itemsize;
    switch (d_state) {
    	...
    	/*
			当解复用器的状态变为 STATE_PAYLOAD 时，意味着它已经成功接收到了头部（header）信息，
			并准备处理接下来的有效载荷数据。这个状态下的主要任务是从输入数据流中读取有效载荷数据，
			然后将这些数据发送到输出端口。
		*/
    	case STATE_PAYLOAD:	// 有效载荷（payload）数据
        // Assumptions:
        // - Input buffer is in the right spot to just start copying
        /*
        	检查缓冲区是否准备好
			首先，通过调用 check_buffers_ready 函数来检查是否有足够的输入和输出缓冲区空间来
			处理当前的有效载荷长度。这个检查确保了在开始复制数据之前，输入和输出都已经准备妥当。

			这些参数用来判断是否满足处理当前有效载荷的条件:
			d_curr_payload_len是当前有效载荷的长度。
			noutput_items, ninput_items, 和 n_items_read分别表示输出项数、输入项数和已读项数，
			
		*/ 
        if (check_buffers_ready(d_curr_payload_len, // 当前有效载荷的长度
                                0,
                                noutput_items,	// 输出项数
                                d_curr_payload_len * (d_items_per_symbol + d_gi),
                                ninput_items,	// 输入项数
                                n_items_read)) {	// 已读项数
            // Write payload
            /*
            	写入有效载荷：
            	如果缓冲区检查通过，copy_n_symbols 函数会被调用来从输入缓冲区（in）复制有效载荷数据
            	到输出缓冲区（out_payload）。复制的数据量基于当前的有效载荷长度（d_curr_payload_len）
            	和每个符号的项目数（d_items_per_symbol加上d_gi，d_gi是一个保护间隔）。
			*/
            copy_n_symbols(in,
                           out_payload,
                           PORT_PAYLOAD,
                           n_items_read_base + n_items_read,
                           d_curr_payload_len);
            // Consume payload
            // We can't consume the full payload, because we need to hold off
            // at least the padding value. We'll use a minimum padding of 1
            // item here.

			/*
				消耗输入项：
				完成数据复制后，需要更新已处理的输入项计数。不过，这里有一个微妙之处：
				我们不能简单地消耗掉所有的有效载荷数据，因为需要保留一定的“填充”数据以
				确保数据的完整性。因此，计算items_to_consume时会减去一个最小的填充项数，
				通常至少为1。这确保了在当前处理周期结束时，输入缓冲区中还留有一些数据，
				以便后续的处理。
			*/
            const int items_padding = std::max(d_header_padding_total_items, 1);
            const int items_to_consume =
                d_curr_payload_len * (d_items_per_symbol + d_gi) - items_padding;
            CONSUME_ITEMS(items_to_consume);
            set_min_noutput_items(d_output_symbols ? 1 : (d_items_per_symbol + d_gi));

			/*
				更新状态:
				最后，解复用器的状态被设置回STATE_FIND_TRIGGER，这意味着在处理完当前有效载荷后，
				解复用器将重新开始寻找下一个触发信号，以准备接收下一个数据包的头部。
			*/
            d_state = STATE_FIND_TRIGGER;
        }
        break;
    	...
    }

#include <iostream>
std::cout << "Debug: The value of variable is " << variable << std::endl;