实现ALOHA协议仿真算法

本文介绍了ALOHA协议的起源、工作原理和演变,包括纯ALOHA协议的简单实现和时隙ALOHA协议的优化,分析了两者在冲突处理和效率上的优缺点。通过模拟实现展示了两种协议的发送过程,并计算了吞吐率。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一.认识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协议模拟结果

jTeE.jpg

5.2 纯ALOHA协议模拟结果

iNzV.jpg

六.补充

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

(设一个时隙Aloha系统的时隙长度为1,所有节点的数据包均等长且等于时隙长度。网络中节点数为m,各节点数据包以泊松过程到达。1.(1) 假设每个节点的数据包到达强度均为,在不同的下,使用计算机仿真时隙Aloha系统数据包传送的成功概率,绘制呼入强度和成功概率的曲线,与理论结果进行对照。注意:节点数要足够多。2.(1) 假设每个节点的数据包达到强度为,以及节点数,采用延时下届。选取合理的等待重传的节点在每一个时隙重传的概率。仿真时隙Aloha系统数据传输过程,统计在不同积压节点数的情况下,到达率及离开率,统计达到率和离开率随的分布情况,和理论值进行对照。调整大小,考察曲线的变化,和理论值进行对照。3.(1) 假设每个节点的数据包到达强度均为。以及节点数m,采用延时下界。选取合理的等待重传节点在每一个时隙重传的概率。仿真时隙CSMA协议,其中空闲时隙长度。绘制到达率和离开率随n的分布情况,和理论值进行对照,调整大小,考察曲线的变化,和理论值进行对照。4.(1) 在(3)的基础上,进一步引入碰撞检测机制,仿真CSMA/CD协议,其中空闲时隙和碰撞时隙长度均为。绘制到达率和离开率随n分布情况,和理论值进行对照,调整大小,考察曲线的变化,和理论值进行对照。 类似与第三问中的解决方法,分别对取0.06 0.1 0.2 0.6观察对比离开率和到达率随n变化的关系。) 和上个上传资源一样,这个是该实验的第二部分,都是自己从网上搜集很多资料整理之后最终呈现的结果。根据课程的更新问题也有所更新,如果有需要参考的就下载这一个就可以啦!有问题随时和我沟通,wink!
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

墨城烟柳ベ旧人殇

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值