实现ALOHA协议仿真算法

一.认识ALOHA协议

ALOHA协议是一种用于无线电通信的多点协议，最初由夏威夷大学开发。它允许多个节点在共享频道上进行通信，而无需中央控制器来协调它们之间的通信。在ALOHA协议中，每个节点都可以任意时刻发送数据，但是如果数据包发生冲突，则需要重新传输。这种冲突的发生可能会导致数据丢失和通信速度变慢。

二.ALOHA的演变

2.1纯ALOHA协议

2.1.1基本认识

纯ALOHA协议最早于1970年由夏威夷大学的Norman Abramson教授提出，作为第一个分组式无线局域网协议。纯ALOHA协议的思想被后来的多种无线通信协议所采用，如IEEE 802.11 WLAN标准就使用了纯ALOHA的基本思想。
纯ALOHA协议是一种用于多用户共享无线信道的简单协议，它允许用户在任意时间将数据包发送到网络中。由于没有时间同步机制，所以可能会出现碰撞和冲突。如果发生了碰撞，那么所有发送的数据包都按照某种随机化算法进行重传。因此，纯ALOHA协议的吞吐量较低，并且有时延较高.

2.1.2基本原理

纯ALOHA协议的原理很简单。它允许多个用户在任何时候向网络中发送数据包，但由于没有同步机制，因此可能会出现碰撞和冲突。

当多个用户同时发送数据包时，就会发生碰撞。为了处理这种情况，纯ALOHA协议规定：一旦某个用户发送了一个数据包，该用户就立即开始等待一个固定时间长度，然后再次随机发送数据包。如果在等待时间过程中没有收到确认信息，那么就可以假定数据包发生了碰撞。在这种情况下，该用户会等待一个随机的时间长度，然后重新发送数据包，以避免与其他用户再次产生碰撞。

2.1.3优缺点

• 优点：简单易实现
• 缺点：吞吐量较低，因为重传等待时间及重新发送数据包的时间会导致通信延迟增加。另外，由于没有时间同步机制，所以存在较高的碰撞率和冲突率，使得通信效率降低。

2.2时隙ALOHA协议

2.2.1基本认识

时隙ALOHA协议是一种无线电通信的协议，它是纯ALOHA协议的优化。

2.2.2基本原理

原理是将时间划分为若干个时隙，每个时隙对应一个固定长度的数据包。在每个时隙开始的时候，发送方可以选择是否发送数据包，如果发送方在该时隙中没有发送数据包，则该时隙被视为空闲时隙，其他发送方可以利用该空闲时隙来发送数据包。

当多个发送方尝试发送数据包并发生冲突时，时隙ALOHA协议会通过重传机制来解决这个问题。如果一个发送方在某个时隙中发送了数据包但是没有收到确认消息，则会在下一个时隙重新发送该数据包。如果两个或多个发送方在同一个时隙中尝试发送数据包，就会发生冲突，此时所有涉及到的发送方都会等待一段时间之后重新尝试发送数据包。

2.2.3优点

时隙ALOHA协议的优点是：

• 简单：时隙ALOHA协议的实现比较简单，只需要将时间划分为若干个时隙，并且没有对传输速率、码率等要求。

• 公平：时隙ALOHA协议避免了数据包冲突的情况，在发送方较少的情况下能够保证公平性，每个发送方都有机会在一个时隙中成功发送数据包。

• 效率高：时隙ALOHA协议的效率比较高，能够达到50%左右的信道利用率。

2.2.4缺点

时隙ALOHA协议的缺点是：

• 数据包冲突：当多个发送方同时发送数据包时，可能会发生数据包冲突，导致数据包丢失。这会降低系统的效率，因为发送方需要花费更多的时间来重传数据包。

• 空闲时隙浪费：在某些时候，大部分的时隙未被使用，这意味着一定数量的空闲时隙被浪费掉了。

• 适用范围有限：时隙ALOHA协议适用于低数据量、低速率的通信场景，例如传感器网络和物联网应用，但不适用于高速率、高数据量的通信场景。

三.实现时隙ALOHA

import random

# 参数设置
tatal = 1000  # 发送时间范围
length = 1  # 帧长
solt = 1  # 时隙
num = 1000  # 总帧数
list = []  # 用来存放每一个数据帧


# 帧类
class Frame:
    def __init__(self, name, time):
        self.name = name  # 帧的名字
        self.send_time = time  # 帧的发送时间


# 随机产生每个帧的发送时间
for i in range(num):
    # 帧的名字用序号代替，发送时间都是整数
    name = i
    send_time = random.randrange(0, tatal + 1, solt)
    frame = Frame(name, send_time)
    list.append(frame)

# 按发送时间属性排序(按时间发送)
list.sort(key=lambda x: x.send_time)  # lambda定义了一个隐含函数x,该函数返回send_time属性


success = 0  # 成功发送帧的数量
conflict = 0  # 发生冲突即本轮传输失败的帧数量

# 有帧发送、并且发送时间在通信时间内才发送
while len(list) > 0 and list[0].send_time <= tatal:
    current_frame = list[0]  # 当前帧一直都是list[0]

    # 冲突检测
    address = []  # 存放冲突帧的name

    # 所有冲突帧存储到address,没有则len(address)=1
    for i in range(len(list)):
        if list[i].send_time == current_frame.send_time:
            address.append(i)

    # 没有冲突,移除列表，同时成功发送帧数量加1
    if len(address) == 1:
        list.remove(current_frame)
        success += 1

    # 发生冲突
    else:
        for i in address:
            list[i].send_time += random.randint(1, tatal + 1) * solt  # 延迟发送时间k个时隙
        conflict += 1  # 冲突帧的数量加1
        list.sort(key=lambda x: x.send_time)  # 重新排序
        address.clear()

# 计算吞吐率
z = success / num
# 输出
print("通信时间:", tatal, "帧长:", length)
print(f"成功发送的帧数量:{success}")
print(f"发送的帧总数量:{num}")
print(f"冲突次数:{conflict}")
print(f"吞吐率:{z}")

四.实现纯ALOHA协议

import random

# 仿真参数设置
t = 1000  # 通信时间
length = 1  # 帧长
total = 1000  # 发送总数


# 数据帧类
class Frame:
    def __init__(self, time):
        self.send_time = time  # 发送时间


# 存储所有数据帧的列表，列表可边循环边增删等操作
list0 = []

# 随机产生数据帧
for i in range(total):
    send_time = random.uniform(0, t+1)
    frame = Frame(send_time)
    list0.append(frame)

# 按发送时间属性排序(按时间发送)
list0.sort(key=lambda x: x.send_time)

success = 0  # 成功发送的帧数量
num = 0  # 记录冲突次数

# 有帧发送并且在通信时间范围内(生成的帧都在t内，但冲突延时后的帧不一定)就发送，否则通信结束
while len(list0) > 0 and list0[0].send_time <= t:
    current_frame = list0[0]  # 当前数据帧

    # 冲突检测
    index = []  # 冲突帧的位置列表
    # 所有冲突帧存储到index,没有则len(index)=1，即存储当前帧的位置
    for j in range(len(list0)):
        if list0[j].send_time - current_frame.send_time < length:
            index.append(j)

    if len(index) == 1:  # 没有冲突
        list0.remove(current_frame)
        success += 1

    else:  # 发生冲突
        for frame in index:
            list0[frame].send_time += random.uniform(0.1, t+1)  # 延迟发送时间
        num += 1
        list0.sort(key=lambda x: x.send_time)  # 重新排序
        index.clear()

# 计算吞吐率
S = success / total

# 输出
print(f"通信时间:{t},帧长:{length}")
print(f"成功发送的帧数量:{success}")
print(f"发送的帧总数量:{total}")
print(f"冲突次数:{num}")
print(f"吞吐率:{S}")

五.运行结果

5.1 时隙ALOHA协议模拟结果

5.2 纯ALOHA协议模拟结果

六.补充

这次的实验理解比较简单，重要的是设计思路。详细的设计思路可以通过学习计算机网络了解。