物联网与射频识别技术，课程实验（四）

实验4—— 基于帧的时隙ALOHA(FSA)算法的实现与性能分析

实验说明： 利用Python或Matlab模拟基于帧的时隙ALOHA算法； 分析标签数量k、帧中所含时隙个数n对信道利用率的影响，其中， 信道利用率=发送数据的时间/(发送数据的时间+信道空闲的时间) 利用Python或Matlab画出相应的曲线，并分析算法的优缺点。

 FSA.py：

"""
1.利用Python或Matlab模拟基于帧的时隙ALOHA算法；
2.分析标签数量k、帧中所含时隙个数n对信道利用率的影响，其中，信道利用率=发送数据的时间/(发送数据的时间+信道空闲的时间)
3.利用Python或Matlab画出相应的曲线，并分析算法的优缺点。
"""
import random

from task4_FSA.Tag import Tag
import numpy as np
import matplotlib.pyplot as plt

font3 = {'family': 'SimHei',
         'weight': 'normal',
         'size': 20,
         }

def cal(tagNum, slotNum):
    """
    function: 计算标签数量为k、帧中所含时隙个数为n时的信道利用率
    :param tagNum: 标签数量
    :param slotNum: 帧中所含时隙个数
    :return: 返回信道利用率
    """
    # print(tagNum, slotNum)
    tagList = []
    vis = []
    for i in range(tagNum):
        tag = Tag()
        # tag.slot = random.randint(0, slotNum)
        tag.id = "tag" + str(i)
        tagList.append(tag)
        vis.append(False)

    flag = 0
    cntSum = 0
    while 1:  # 不知道需要多少帧数才能完成所有标签发送
        for i in range(tagNum):  #新的一帧 全部重置随机数
            tagList[i].slot = random.randint(0, slotNum)

        for j in range(slotNum):
            cnt = 0
            index = None

            for i in range(tagNum):
                cntSum += 1
                if vis[i]:
                    flag += 1
                    continue
                if tagList[i].slot == 0:  # 该标签还没有静默
                    cnt += 1
                    index = i
                tagList[i].slot -= 1

            if flag >= tagNum:
                print(tagNum, cntSum, tagNum / cntSum)
                return tagNum / cntSum
            if cnt == 1:  # 未冲突 只有一个标签在该时隙发送数据 即单时隙
                vis[index] = True
            elif cnt > 1:  #冲突时隙
                pass
            else:  # 空时隙
                pass

def main():
    tagNum = 250
    slotNum = 70

    ratio = []
    # print('---------------标签数量k对信道利用率的影响--------------')
    #
    # for i in range(1, tagNum):
    #     rate = []
    #     for j in range(3):
    #         t = cal(i, i)  # 默认每帧时隙数为最优帧长 即tagNum
    #         rate.append(t)
    #     ratio.append(np.average(rate))
    #
    # plt.plot(np.arange(1, tagNum), ratio, color='r', linestyle='--', marker='*', linewidth=2.0)
    # plt.xlabel('标签数量', font3)
    # plt.ylabel('信道利用率', font3)
    # plt.show()
    #
    # ratio.clear()
    # print('---------------帧中所含时隙个数n对信道利用率的影响--------------')
    # for i in range(5, slotNum):
    #     rate = []
    #     for j in range(3):
    #         t = cal(25, i)  # 默认有25个标签 帧长从1到slotNum
    #         rate.append(t)
    #     ratio.append(np.average(rate))
    #     # print(i, np.average(rate))
    #
    # plt.plot(np.arange(5, slotNum), ratio, color='g', linestyle='-', marker='*', linewidth=2.0)
    # plt.xlabel('帧中所含时隙个数', font3)
    # plt.ylabel('信道利用率', font3)
    # plt.show()

    ratio.clear()
    print('---------------不同帧长对信道利用率的影响--------------')

    for i in range(1, tagNum*2):
        rate = []
        for j in range(3):
            t = cal(i, 32)  # 默认每帧时隙数为最优帧长 即tagNum
            rate.append(t)
        ratio.append(np.average(rate))

    plt.plot(np.arange(1, tagNum*2), ratio, color='r', linestyle='-', marker='*', linewidth=2.0, label='32')

    for i in range(1, tagNum*2):
        rate = []
        for j in range(3):
            t = cal(i, 64)  # 默认每帧时隙数为最优帧长 即tagNum
            rate.append(t)
        ratio.append(np.average(rate))

    plt.plot(np.arange(1, tagNum*2), ratio, color='g', linestyle='-', marker='*', linewidth=2.0, label='64')

    for i in range(1, tagNum*2):
        rate = []
        for j in range(3):
            t = cal(i, 128)  # 默认每帧时隙数为最优帧长 即tagNum
            rate.append(t)
        ratio.append(np.average(rate))

    plt.plot(np.arange(1, tagNum*2), ratio, color='b', linestyle='-', marker='*', linewidth=2.0, label='128')
    plt.xlabel('标签数量', font3)
    plt.ylabel('信道利用率', font3)

    plt.show()

if __name__ == '__main__':
    main()

Tag.py可以不用管，没有用到

常用的防碰撞算法其特点：

（1）ALOHA：随机竞争

• 核心思想：需要发送的数据包立刻发送
• 最大信道利用率：18.4%

（2）时隙ALOHA：

• 核心思想：时间分成小的间隙，电子标签只在下一个间隙开始时才可以发送数据包
• 最大信道利用率：36.8%

（3）动态时隙ALOHA：

• 发生潜在碰撞时逐步增加标签可用的时隙数，直到有一个标签可以发送成功
• （根据标签碰撞和空闲的概率来调整帧长）

（4）二进制搜索算法

• 只有符合限制的标签才应答