Aloha算法（五）基于分组的动态帧时隙Aloha算法

Zoo1e

已于 2024-02-24 12:01:05 修改

阅读量234

点赞数

分类专栏： RFID标签防碰撞算法仿真文章标签： Aloha系列算法

于 2024-02-24 12:00:29 首次发布

本文链接：https://blog.csdn.net/weixin_45706217/article/details/136270085

版权

RFID标签防碰撞算法仿真专栏收录该内容

4 篇文章 0 订阅

订阅专栏

为解决RFID系统中动态帧时隙Aloha算法在标签数量超过256时效率降低的问题，提出了基于分组的动态帧时隙Aloha算法。该算法根据标签数量与最大帧长的关系进行分组，并对每个分组应用动态帧时隙算法，以提高识别效率。

摘要由CSDN通过智能技术生成

因 RFID 系统硬件条件的限制，帧长不能无限增加(8,16,32,64,128,256)，帧长最大只能包含 256 个时隙，因此当阅读器识别范围内的标签数远大于 256 时，动态帧时隙算法的识别效率显著降低。

因此这里提出，基于分组的动态帧时隙(Group-Dynamic-Framed-Slotted)-Aloha 算法，根据标签与最大帧长的倍数关系，对标签进行分组，再对每个分组使用动态帧时隙算法。基于分组的动态帧时隙算法代码实现

# encoding=utf-8
import math
import time

from CommonAlgrithom import *


def divideGroup(tags):
    """
    256个标签为一组，对tags进行分组
    :param tags: 标签列表
    :return: 分组后的标签列表(二维)
    """
    for i in range(len(tags)):
        tags[i].slotId = -1

    matrixTag = []
    groupNum = math.ceil(tagNums / 256)
    print(f"分组长度：{groupNum}")
    if groupNum == 1:
        matrixTag.append(tags)
    else:
        i = 0
        while i < groupNum - 1:
            matrixTag.append(tags[i * 256:(i + 1) * 256])
            i += 1
        matrixTag.append(tags[i * 256:])
    # for i in range(len(matrixTag)):
    #     print(f"第{i+1}个分组为：")
    #     showTags(matrixTag[i])
    return matrixTag


def groupBasedFrameSlotAloah(tags, binaryLength=96, slot=1, ack=1):
    """
    :param tags: 标签列表
    :param binaryLength: 标签EPC编码长度
    :param slot: 一个时隙包含多少个确认时间
    :param ack: 标签发送数据包后，所等待的确认时间
    :param slot: 时隙长度
    :return performance
    """
    matrixTag = divideGroup(tags)
    performance = TreePerformance()
    performance.algName = groupBasedFrameSlotAloah.__name__

    startTime = time.time()
    for groupIndex in range(len(matrixTag)):
        print(f"groupIndex:{groupIndex}   len(matrixTag):{len(matrixTag)}")
        while len(matrixTag[groupIndex]) > 0:
            frame = getFrameLength(len(matrixTag[groupIndex]))
            print(f"第{groupIndex + 1}分组当前有{len(matrixTag[groupIndex])}个标签,对应帧长为{frame}")
            for index in range(len(matrixTag[groupIndex])):
                matrixTag[groupIndex][index].slotId = random.randint(1, frame)
            for frameIndex in range(1, frame + 1):
                responseList = [tag for tag in matrixTag[groupIndex] if tag.slotId == frameIndex]  # 选择了当前时隙号的所有标签
                performance.tagDataCount += len(responseList) * binaryLength

                # 判断是否冲突
                if len(responseList) == 1:
                    showSuccess("成功识别标签: " + str(responseList[0].id))
                    performance.successSlot += 1
                    performance.successNum += 1
                    matrixTag[groupIndex].remove(responseList[0])
                elif len(responseList) > 1:
                    showError("发生碰撞！")
                    performance.collisionSlot += 1
                else:
                    showWarning("无标签选择该时隙")
                    performance.emptySlot += 1
            performance.totalSlot += ack * slot * frame
    endTime = time.time()
    performance.aggregateResult(endTime, startTime)
    performance.showPerformance()
    return performance


tagNums = 1000  # 总标签数量
binaryLength = 96
ack = 1  # 标签发送数据包后，等待确认的时间
slot = 1  # 一个时隙包含多少个确认时间
tags = randomTag(tagNums)
result = groupBasedFrameSlotAloah(tags, binaryLength, slot, ack)
# print(f"标签总数为:{tagNums}  总限时为:{totalTime}  时隙长度为:{slot}")
# print(f"算法总耗时:{result[0]}  成功识别的标签个数为:{result[1]}  碰撞次数为:{result[2]}")