基于Simpy/Python的通信网络仿真工具（二）：多主机、端口互联实现数据包转发与交换机仿真

已于 2023-10-08 21:23:49 修改
阅读量459 收藏 4
点赞数
文章标签： 网络 python
于 2023-10-08 21:02:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhenwei7799/article/details/133688331
版权

基于Simpy的通信网络仿真工具（二）：多主机、端口互联实现数据包转发与交换机仿真

基于Simpy/Python的通信网络仿真工具（一）：数据包生成，转发和接收

Host模块

在主机(Host)中具有数据包生成器(Pg)和接收器(Ps)，实现代码如下

class Host(object):
    """ 
    功能: 实现数据包产生、发出和接收
    参数
    -------
        address : 地址
        dist : 时隙大小
        dst_adrees : 目的地址列表
        size_list : 包大小列表
        interval : 包产生间隔时间
        rec_arrivals: 包接收间隔时间
        absolute_arrivals: 包接收时间
        debug: 日志打印
    """
    def __init__(self, env, address, dst_address, interval=None, rec_arrivals=False, absolute_arrivals=False, debug=False) -> None:
        self.env = env
        self.address = address
        self.pg = PacketGenerator(env, src=address, dst_list=dst_address, interval=interval)
        self.ps = PacketSink(
            env, host=address, rec_arrivals=rec_arrivals, absolute_arrivals=absolute_arrivals, debug=debug)

    # 设置包的大小信息
    def setPktSize(self, pkt_size_list):
        """ 
        pkt_size_list : size列表
        """
        self.size_list = pkt_size_list
    # 连接(out)目标交换机
    def setLink(self, target):
        self.pg.out = target.in_port

Port模块

一个端口(Port)需要同时具备接收、转发和发出功能，代码如下

class Port(object):
    """ 
    功能: 接收和转发全功能端口，实现端口的接收和转发
    参数
    ------
        env: 运行环境
        port_id: 端口的id
        trans_list: 内部端口的连接列表, A_in --> B_out, C_out
        table: 转发规则表, src-dst : port_out
        valid_time: 流表有效时间
        send_rate: out端口的传输速率
        queue_limit: 队列最大长度
        is_limit: 是否丢包
        debug: 输出执行信息
    """
    def __init__(self, env, port_id, trans_list, table=None, valid_time=None,
                 send_rate=0, queue_limit=None, is_limit=True, debug=False) -> None:
        self.env = env
        self.switch_id = None
        self.port_id = port_id 
        self.queue = []   # 端口队列记录
        self.drop = []    # 端口丢包记录
        self.in_port = SwitchPortIn(env=env, trans_list=trans_list, valid_time=valid_time,
                                                    table=table, debug=debug)
        self.out_port = SwitchPortOut(env=env, address=None, rate=send_rate, qlimit=queue_limit,
                                                      limit_bytes=is_limit, debug=debug)

    # 设置转发表（判断包应该转发到哪个port的out）
    def setTable(self, table):
        self.in_port.table = table

    # 设置out端口的连接对象
    def setOutObj(self, out):
        self.out_port.out = out

    # 设置in端口的连接对象
    def setTransPort(self, target_list):
        for i in range(len(target_list)):
            self.in_port.out[i] = target_list[i].out_port

    # 获取out端口的队列
    def getQueue(self):
        return self.out_port.queue

    # 输出out端口的丢包情况
    def getOutDrop(self):
        return self.out_port.out_drop

    def __repr__(self):
        return "switch_address :{}, port_id :{}".format(self.switch_id, self.port_id)

三主机、端口传输仿真

在数据包数据包生成，转发和接收和基础上，本部分根据以下拓扑实现，数据转发仿真
在这里插入图片描述

# Port仿真, 三port, 三host
import simpy
import random

UNTIL_TIME = 10 # 仿真时间
def constArrival():
    return 0.8   # time interval
def getTransList1():
    return [2, 3]
def getTransList2():
    return [1, 3]
def getTransList3():
    return [1, 2]
# 生成转发规则
def getTable1():
    return {"H1-H2": 2, "H1-H3": 3}
def getTable2():
    return {"H2-H1": 1, "H2-H3": 3}
def getTable3():
    return {"H3-H1": 1, "H3-H2": 2}

if __name__=='__main__':
    port_rate = 1200.0
    env = simpy.Environment()  # Create the SimPy environment
    h1 = Host(env, "H1", dst_address=["H2", "H3"], interval=constArrival, rec_arrivals=True, debug=False)
    h2 = Host(env, "H2", dst_address=["H1", "H3"], interval=constArrival, rec_arrivals=True, debug=False)
    h3 = Host(env, "H3", dst_address=["H1", "H2"], interval=constArrival, rec_arrivals=True, debug=False)
    
    pt1 = Port(env=env, port_id = 1, trans_list=getTransList1(), table=getTable1(), 
            send_rate=port_rate, queue_limit=1001, debug=False)
    pt2 = Port(env=env, port_id = 2, trans_list=getTransList2(), table=getTable2(),
            send_rate=port_rate, queue_limit=1001, debug=False)  # rate 是波特率
    pt3 = Port(env=env, port_id = 3, trans_list=getTransList3(), table=getTable3(),
            send_rate=port_rate, queue_limit=1001, debug=False)  # rate 是波特率
    h1.pg.out = pt1.in_port
    pt1.setTransPort(target_list=[pt2, pt3])
    pt2.setOutObj(h2.ps)
    
    h2.pg.out = pt2.in_port
    pt2.setTransPort(target_list=[pt1, pt3])
    pt1.setOutObj(h1.ps)

    h3.pg.out = pt3.in_port
    pt3.setTransPort(target_list=[pt1, pt2])
    pt3.setOutObj(h3.ps)

    env.run(until=UNTIL_TIME)
    print("received: {}, queuing: {}, out dropped {}, sent {}".format(
        h1.ps.packets_rec + h2.ps.packets_rec + h3.ps.packets_rec, 
        len(pt1.out_port.queue)+ len(pt2.out_port.queue) + len(pt3.out_port.queue),
        len(pt1.getOutDrop())+ len(pt2.getOutDrop()) + len(pt3.getOutDrop()),
        h1.pg.packets_sent + h2.pg.packets_sent + h3.pg.packets_sent))

    print("h1 received ids: {}".format(h1.ps.arrivals_id))
    print("h2 received ids: {}".format(h2.ps.arrivals_id))
    print("h3 received ids: {}".format(h3.ps.arrivals_id))
    print("pt1 queue ids : {}".format([pkt.id for pkt in pt1.out_port.queue]))
    print("pt2 queue ids: {}".format([pkt.id for pkt in pt2.out_port.queue]))
    print("pt3 queue ids: {}".format([pkt.id for pkt in pt3.out_port.queue]))
    print("pt1 out drop ids: {}".format([pkt.id for pkt in pt1.out_port.out_drop]))
    print("pt2 out drop ids: {}".format([pkt.id for pkt in pt2.out_port.out_drop]))
    print("pt3 out drop ids: {}".format([pkt.id for pkt in pt3.out_port.out_drop]))

结果如下：

received: 42, queuing: 26, out dropped 4, sent 72
h1 received ids: ['H2-H1-1', 'H3-H1-1', 'H2-H1-3', 'H3-H1-3', 'H2-H1-5', 'H3-H1-5', 'H2-H1-7', 'H3-H1-7', 'H2-H1-9', 'H3-H1-9', 'H2-H1-11', 'H3-H1-11', 'H2-H1-13', 'H3-H1-13', 'H2-H1-15']
h2 received ids: ['H1-H2-1', 'H3-H2-2', 'H1-H2-3', 'H3-H2-4', 'H1-H2-5', 'H3-H2-6', 'H1-H2-7', 'H3-H2-8', 'H1-H2-9', 'H3-H2-10', 'H1-H2-11', 'H3-H2-12', 'H1-H2-13', 'H3-H2-14', 'H1-H2-15']
h3 received ids: ['H1-H3-2', 'H2-H3-2', 'H1-H3-4', 'H2-H3-4', 'H1-H3-6', 'H2-H3-6', 'H1-H3-8', 'H2-H3-8', 'H1-H3-10', 'H2-H3-10', 'H1-H3-12', 'H2-H3-12']
pt1 queue ids : ['H3-H1-15', 'H2-H1-17', 'H3-H1-17', 'H2-H1-19', 'H3-H1-19', 'H2-H1-21', 'H3-H1-21', 'H2-H1-23', 'H3-H1-23'] 
pt2 queue ids: ['H3-H2-16', 'H1-H2-17', 'H3-H2-18', 'H1-H2-19', 'H3-H2-20', 'H1-H2-21', 'H3-H2-22', 'H1-H2-23', 'H3-H2-24']  
pt3 queue ids: ['H1-H3-14', 'H2-H3-14', 'H1-H3-16', 'H2-H3-16', 'H1-H3-18', 'H1-H3-20', 'H1-H3-22', 'H2-H3-22']
pt1 out drop ids: []
pt2 out drop ids: []
pt3 out drop ids: ['H2-H3-18', 'H2-H3-20', 'H1-H3-24', 'H2-H3-24']

通过设置数据包产生间隔时间，影响网络的拥塞程度。

def constArrival():
    return 0.6   # time interval

运行结果

received: 44, queuing: 37, out dropped 15, sent 96
h1 received ids: ['H2-H1-1', 'H3-H1-1', 'H2-H1-3', 'H3-H1-3', 'H2-H1-5', 'H3-H1-5', 'H2-H1-7', 'H3-H1-7', 'H2-H1-9', 'H3-H1-9', 'H2-H1-11', 'H3-H1-11', 'H2-H1-13', 'H3-H1-13', 'H2-H1-15']
h2 received ids: ['H1-H2-1', 'H3-H2-2', 'H1-H2-3', 'H3-H2-4', 'H1-H2-5', 'H3-H2-6', 'H1-H2-7', 'H3-H2-8', 'H1-H2-9', 'H3-H2-10', 'H1-H2-11', 'H3-H2-12', 'H1-H2-13', 'H3-H2-14']
h3 received ids: ['H1-H3-2', 'H2-H3-2', 'H1-H3-4', 'H2-H3-4', 'H1-H3-6', 'H2-H3-6', 'H1-H3-8', 'H2-H3-8', 'H1-H3-10', 'H2-H3-10', 'H1-H3-12', 'H2-H3-12', 'H1-H3-14', 'H2-H3-14', 'H1-H3-16']
pt1 queue ids : ['H3-H1-15', 'H2-H1-17', 'H3-H1-17', 'H2-H1-19', 'H2-H1-21', 'H3-H1-21', 'H2-H1-23', 'H3-H1-23', 'H2-H1-25', 'H3-H1-25', 'H2-H1-29', 'H3-H1-29']
pt2 queue ids: ['H1-H2-15', 'H3-H2-16', 'H1-H2-17', 'H3-H2-18', 'H1-H2-19', 'H1-H2-21', 'H3-H2-24', 'H3-H2-26', 'H1-H2-27', 'H3-H2-28', 'H1-H2-29', 'H3-H2-30', 'H1-H2-31', 'H3-H2-32']
pt3 queue ids: ['H2-H3-16', 'H1-H3-18', 'H1-H3-20', 'H2-H3-20', 'H1-H3-22', 'H1-H3-24', 'H1-H3-26', 'H1-H3-28', 'H2-H3-28', 'H1-H3-30', 'H2-H3-30']
pt1 out drop ids: ['H3-H1-19', 'H2-H1-27', 'H3-H1-27', 'H2-H1-31', 'H3-H1-31']
pt2 out drop ids: ['H3-H2-20', 'H3-H2-22', 'H1-H2-23', 'H1-H2-25']
pt3 out drop ids: ['H2-H3-18', 'H2-H3-22', 'H2-H3-24', 'H2-H3-26', 'H1-H3-32', 'H2-H3-32']

对比结果可知，间隔越小，网络丢包率越高，队列排队程度越长。

交换机仿真

在三端口的拓扑中，三端口合并即为一个交换机，如下图所示
在这里插入图片描述
整合了端口的交换机代码如下，主要功能包括初始端口，连接端口对应的设备

class Switch(object):
    def __init__(self, env, address, port_num, send_rate, queue_limit, valid_time=None, ctrler=None, debug=False):
        self.address = address # 交换机的地址
        self.port_num_list = [i for i in range(port_num)]  # 端口编号列表
        self.port_list = [None for _ in range(port_num)]  # 端口列表
        # 生成每个端口
        for port_i in range(port_num):
            trans_list = self.port_num_list.copy()  # 对象数组采用copy
            trans_list.remove(port_i)  # 生成port_i 对应的 转发端口列表
            self.port_list[port_i] = Port(
                env, switch_addr = self.address, port_id = port_i, trans_list=trans_list, valid_time=valid_time, table=None, send_rate=send_rate, queue_limit=queue_limit, debug=debug)

        # 连接交换机内部的端口
        for port in self.port_list:
            trans_list = self.port_list.copy()
            trans_list.remove(port)  # 生成port 对应的 转发端口
            port.setTransPort(target_list=trans_list)  # 连接转发端口

    # 设置转发表
    def setTables(self, tables_list):
        for i in range(len(tables_list)):
            self.port_list[i].setTable(tables_list[i])

    # 设置连接对象
    def setLink(self, link_list, port_list):
        """ 
        link_list : 连接对象(Port or Host)
        port_list : 目标对象的端口编号，连接主机时为空
         """
        # print([host.address for host in link_list])
        # print(self.port_list)
        for i in range(len(link_list)):
            if type(link_list[i]) is Host:
                # 设置(out)连接对象
                self.port_list[i].setOutObj(link_list[i].ps)
                # 设置(in)连接对象
                link_list[i].setLink(self.port_list[i])
            else:
                # 设置(out)连接对象, 交换机与交换机之间均为 in-->out
                self.port_list[i].setOutObj(link_list[i].port_list[port_list[i]].in_port)
        
    def __repr__(self):
        return "address :{}".format(self.address)

转发测试代码如下

def constArrival():
    return 0.8   # time interval
def getTable1():
    return {"H1-H2": 1, "H1-H3": 2} # 交换机的端口编号 从0开始
def getTable2():
    return {"H2-H1": 0, "H2-H3": 2}
def getTable3():
    return {"H3-H1": 0, "H3-H2": 1}

if __name__=='__main__':
    port_rate = 1200.0
    env = simpy.Environment()  # Create the SimPy environment
    h1 = Host(env, address = "H1", dst_address=["H2", "H3"], interval=constArrival, rec_arrivals=True, debug=False)
    h2 = Host(env, address = "H2", dst_address=["H1", "H3"], interval=constArrival, rec_arrivals=True, debug=False)
    h3 = Host(env, address = "H3", dst_address=["H1", "H2"], interval=constArrival, rec_arrivals=True, debug=False)
    
    swicth = Switch(env=env, address = 'S1', port_num=3, send_rate=port_rate, queue_limit=1001, debug=False)
    link_list = [h1, h2, h3]
    swicth.setLink(link_list=link_list, port_list=[]) 
    swicth.setTables([getTable1(), getTable2(), getTable3()])
    env.run(until=UNTIL_TIME)
    print("received: {}, queuing: {}, out dropped {}, sent {}".format(
        h1.ps.packets_rec + h2.ps.packets_rec + h3.ps.packets_rec, 
        len(swicth.port_list[0].out_port.queue)+ len(swicth.port_list[1].out_port.queue) + len(swicth.port_list[2].out_port.queue),
        len(swicth.port_list[0].getOutDrop())+ len(swicth.port_list[1].getOutDrop()) + len(swicth.port_list[2].getOutDrop()),
        h1.pg.packets_sent + h2.pg.packets_sent + h3.pg.packets_sent))

    print("h1 received ids: {}".format(h1.ps.arrivals_id))
    print("h2 received ids: {}".format(h2.ps.arrivals_id))
    print("h3 received ids: {}".format(h3.ps.arrivals_id))
    print("pt1 queue ids : {}".format([pkt.id for pkt in swicth.port_list[0].out_port.queue]))
    print("pt2 queue ids: {}".format([pkt.id for pkt in swicth.port_list[1].out_port.queue]))
    print("pt3 queue ids: {}".format([pkt.id for pkt in swicth.port_list[2].out_port.queue]))
    print("pt1 out drop ids: {}".format([pkt.id for pkt in swicth.port_list[0].out_port.out_drop]))
    print("pt2 out drop ids: {}".format([pkt.id for pkt in swicth.port_list[1].out_port.out_drop]))
    print("pt3 out drop ids: {}".format([pkt.id for pkt in swicth.port_list[2].out_port.out_drop]))

结果如下：

received: 35, queuing: 34, out dropped 3, sent 72
h1 received ids: ['H2-H1-1', 'H3-H1-1', 'H2-H1-3', 'H3-H1-3', 'H2-H1-5', 'H3-H1-5', 'H2-H1-7', 'H3-H1-7', 'H2-H1-9', 'H3-H1-9', 'H2-H1-11']
h2 received ids: ['H1-H2-1', 'H3-H2-2', 'H1-H2-3', 'H3-H2-4', 'H1-H2-5', 'H3-H2-6', 'H1-H2-7', 'H3-H2-8', 'H1-H2-9', 'H3-H2-10', 'H1-H2-11', 'H3-H2-12']
h3 received ids: ['H1-H3-2', 'H2-H3-2', 'H1-H3-4', 'H2-H3-4', 'H1-H3-6', 'H2-H3-6', 'H1-H3-8', 'H2-H3-8', 'H1-H3-10', 'H2-H3-10', 'H1-H3-12', 'H2-H3-12']
pt1 queue ids : ['H3-H1-11', 'H2-H1-13', 'H3-H1-13', 'H2-H1-15', 'H3-H1-15', 'H2-H1-17', 'H3-H1-17', 'H2-H1-19', 'H3-H1-19', 'H2-H1-21', 'H3-H1-21']
pt2 queue ids: ['H1-H2-13', 'H3-H2-14', 'H1-H2-15', 'H3-H2-16', 'H1-H2-17', 'H3-H2-18', 'H1-H2-19', 'H3-H2-20', 'H3-H2-22', 'H1-H2-23', 'H3-H2-24']
pt3 queue ids: ['H1-H3-14', 'H2-H3-14', 'H1-H3-16', 'H2-H3-16', 'H1-H3-18', 'H2-H3-18', 'H1-H3-20', 'H2-H3-20', 'H1-H3-22', 'H2-H3-22', 'H1-H3-24', 'H2-H3-24']
pt1 out drop ids: ['H2-H1-23', 'H3-H1-23']
pt2 out drop ids: ['H1-H2-21']
pt3 out drop ids: []

比较三端口和交换机仿真可知，交换机主要是将端口的初始化和连接关系进行整合封装，提高效率。
然而，目前交换机的转发规则时固定的，如需要动态改变转发策略，则需要控制器的加入，并动态下发转发流表。

欢迎通过企鹅(488128665)进行交流！
以上仿真内容代码下载：基于Simpy/Python的通信网络仿真工具

致书
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Python-simpy的仿真模拟
lay523的博客
03-12 3288
Simpy包的简单使用Simpy包基本概念Environment例子1-汽车启停模拟例子2-汽车充电模拟如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 Simpy包 基本概念 Simpy-制造仿真：SimPy 是离散事件驱动的仿真库 仿真技术是再现系统动态行为、分析系统配
python通信系统仿真_python实现TCP/UDP通信
weixin_31001855的博客
12-29 828
一.说明对于TCP/udp的说明已经很多了，我在这里只是简单的说明一下二.套接字scoket套接字是一种具有之前所说的“通信端点”概念的计算网络数据结构。相当于电话插口，没它无法通信，这个比喻非常形象。套接字起源于20世纪70年代加州伯克利分校版本的Unix，即BSD Unix。又称为“伯克利套接字”或“BSD套接字”。最初套接字被设计用在同一台主机上多个应用程序之间的通讯，这被称为进程间通讯或I...
人工智能课程的期末大作业：一个基于 Python 语言完成的 SimPy 仿真项目
11-19
人工智能课程的期末大作业，是基于 Python 语言完成的 SimPy 仿真项目及相应的文档和课程报告。项目旨在锻炼学生独立思考的能力，培养项目业务能力和创新思维。 文件说明 src 代码目录 LICENCE LGPL 3.0 开源许可证 tutor 自己编写的培训资料及教程文件，主要是向作业小组成员展示 Python 各个工具的使用方法 misc 杂项文件（找不到的资料都在这个文件夹里面） demo 老师给出的一组示例代码 backup 备份文件 LICENCE 项目开源许可证 requirements.txt Python 的项目依赖
Python实现两端通信，模拟网络监控(单任务版本)
03-29
Python实现UDP通信，其中包含server端，client端，以及前端展示界面
【Python】Python 仿真OFDM发射机、信道和接收机-实现多种调制方式
BetterBench的博客
11-18 7875
目录1 引言2 Python实现2.1 初始化和定义函数2.1.1 初始化参数2.1.2 可视化导频插入的格式2.1.3 定义调制和解调方式2.1.4 定义信道2.2 OFDM仿真过程2.2.1 发送端2.2.2 信道2.2.3 接收端 1 引言 OFDM的通信系统仿真，Matlab实现的版本比比皆是，Python版本的底层详细的仿真过程缺少之又少，本人根据Commpy工具包，实现了OFDM的信号发射、经过信道、接收端接收的过程。并可视化了导频的插入方式、信道冲击响应、信号解调前的星座映射和解调后的星座映射
【Python】SimPy的使用示例
Twinkle
11-26 9964
使用SimPY进行离散事件仿真 SimPY是一个Python下的第三方库，可以方便的进行离散事件的仿真。仿真速度比较快。下面记录一下我的一点心得，不保证完全正确，供参考。 安装 $ pip install -U simpy pycharm可以再File | Settings | Project: Simulation | Project Interpreter中添加  主要概念 E...
chatgpt赋能python：Python如何模拟硬件和软件通信
test100t的博客
06-15 225
在计算机领域中，硬件和软件通信是指向硬件设备发送指令或从硬件设备读取数据的过程。这些指令告诉硬件设备执行何种操作，例如读取/写入数据、控制电流等。同时，从硬件设备读取到的数据可以被软件用于计算和分析。本文由chatgpt生成，文章没有在chatgpt生成的基础上进行任何的修改。以上只是chatgpt能力的冰山一角。作为通用的Aigc大模型，只是展现它原本的实力。对于颠覆工作方式的ChatGPT，应该选择拥抱而不是抗拒，未来属于“会用”AI的人。🧡AI职场汇报智能办公文案写作效率提升教程 🧡专注于。
基于Simpy/Python的通信网络仿真工具（一）：数据包生成，转发和接收
zhenwei7799的博客
10-08 1454
本系列博客内容主要是在“Basic Network Simulations and Beyond in Python Introduction”的基础上进行创作。在数据包生成与接收的基础上，增加端口的转发和拓扑连接，实现数据包的成功转发和丢包，排队等。由于没有设置包处理速度和传播速度，Ps接收包的时间和包发出时间一致。包生成器仿真拓扑如下。
python通信系统仿真_Python----matlab的兄弟语言（用python（x，y）仿真ofdm系统）
weixin_32323283的博客
12-29 1364
最近爱上Python(蟒蛇语言)这个编程语言，因为她简单，功能强大，而且还免费，网上能找到关于她的大量开源代码，因而便于学习。对于学工程，习惯用matlab作仿真的童鞋，假如想学一门语言玩编程的话，我极力推荐python！仅仅花了一个下午就将她的语法学了一遍，因为她实在太像我比较熟的matlab了。matlab总是需要库的支持，python也是；m语言中数组为基础，python中序列、列表为基础；...
python 通信系统仿真_深入浅出通信原理连载22-40（Python代码版）
weixin_39830020的博客
12-09 1050
深入浅出通信原理Python代码版深入浅出通信原理是陈爱军的心血之作，于通信人家园连载，此处仅作python代码笔记训练所用陈老师的连载从多项式乘法讲起，一步一步引出卷积、傅立叶级数展开、旋转向量、三维频谱、IQ调制、数字调制等一系列通信原理知识连载27 信号调制的意义无线通信系统是空间辐射的方式传送信号的，而现有天线大都是全向天线，天线尺寸\(l\)大于被辐射波长\(\lambda\)十分之一时...
csa-streetmap:使用Simpy，OSMnx和Leaflet.js在Python中进行城市物流网络仿真
05-02
csa-streetmap 使用的简单城市配送网络。 带有的基于浏览器的可选动画。 快速开始 旋转一个在服务的容器： docker-compose up geo-web-animation
基于Simpy_的部队装备维修仿真系统设计与实现.pdf
02-15
基于Simpy_的部队装备维修仿真系统设计与实现.pdf
16QAM基带通信系统仿真
04-17
一个完整16QAM基带通信系统的仿真，仿真结果比较理想
NS-3网络仿真软件
09-25
NS3是一个离散事件模拟器，旨在满足学术研究和教学的需求。NS3项目是一个始于2006年的开源项目，负责开发ns3软件。 NS-3并不是NS-2的扩展，而是一个全新的模拟器
ofdm_OFDM的Pyhon仿真_pythonOFDM_pythonofdm通信工程_
09-29
python仿真ofdm代码，较短，具有一定参考价值，没有数据包检测部分。
基于Simpy/Python的通信网络仿真工具
10-08
使用Python语言，基于Simpy库函数实现通信网络仿真，包括主机、端口和交换机数据传输\ 目录： 1.数据包生成接收仿真: genSim.py 2.端口传输仿真: portSim.py 3.三端口传输仿真: portLinkSim.py 4.交换机传输仿真: ...
python使用simpy仿真模拟MM1K(M/M/1/K)队列
11-27
python使用simpy仿真模拟MM1K(M/M/1/K)队列。目前看是csdn中唯一一个用python写的代码，个人写的，不用担心抄袭问题
人工智能大作业Python 语言完成的 SimPy 仿真.zip
最新发布
05-17
Python 语言完成的 SimPy 仿真.zipPython 语言完成的 SimPy 仿真.zipPython 语言完成的 SimPy 仿真.zipPython 语言完成的 SimPy 仿真.zipPython 语言完成的 SimPy 仿真.zipPython 语言完成的 SimPy 仿真.zipPython ...
python 利用simpy工具包设计一个仿真应用
i道i的博客
11-02 449
SimPy 可以用于构建复杂的离散事件系统，如排队系统、库存系统等。我们假设均匀加减速，启动加速度取2m/s^2,刹车加速度取10m/s^2，设最大速度10m/s（36km/h），车长4.4m，这样最大刹车距离为5m。假设有一条红绿灯路口的直行车道（假设只有一条，一条和多条相似），现在有一些车要过红绿灯，绿灯20s，黄灯5s，路口40m。这里采用网上五菱宏光s的加速度和刹车数据，零百14.3s左右，100码刹车42m，仪器显示加速度数值约为40km/h。这里仿真了一个直行红绿灯路口。
基于Python的数字通信系统的仿真
04-29
数字通信系统的仿真可以使用Python中的许多库和工具来实现。以下是一些可能有用的库和工具： 1. NumPy：用于数学计算和矩阵操作的库。 2. SciPy：用于信号处理、滤波器设计和频谱分析的库。 3. Matplotlib：用于数据可视化和绘图的库。 4. PyAudio：用于音频处理的库。 5. Scikit-learn：用于机器学习和数据挖掘的库。 6. GNU Radio：用于软件定义无线电的工具。 7. SimPy：用于离散事件仿真的库。 这些库和工具可以用来构建数字通信系统的各个组件，例如调制器、解调器、编码器、解码器、信道模型和误码率分析器等等。可以使用Python中的类和函数来组织这些组件并进行交互，以实现完整的数字通信系统仿真。 需要注意的是，数字通信系统的仿真可能需要大量的计算和内存资源，因此可能需要使用高性能计算机或云计算服务来进行仿真。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值