SDSN：基于SDN的卫星网络

YangShine01

已于 2024-04-08 12:09:17 修改

阅读量1.7k

点赞数 12

文章标签： python 网络协议网络

于 2023-06-23 17:58:14 首次发布

本文链接：https://blog.csdn.net/weixin_46569289/article/details/131352069

版权

SDSN：基于SDN的卫星网络

前段时间一直在做跟SDN与卫星网络相关的毕设，学习了很多东西也走了很多弯路，所以想分享一下自己的学习过程，并且对相关的知识做一个总结。

有很多同学问我，所以放一下我自己关于这个项目的github链接：

https://github.com/YangShine-GenZ/SDN_Satellite.git

思路框架

研究过程

完成整个研究任务需要大致了解一下几个方面：

卫星网络是如何构建的，他有怎么样的参数，轨道是什么样的，卫星是如何运动的，星体模型是什么样的？例如一个常见的铱星(Iridium)系统。
SDN是一个什么样的概念，他的应用场景和关键技术是怎么样的？他在卫星网络中又是如何被使用的？
SDN控制器与交换器各个是什么样的概念，是如何实现如何应用的。OpenFlow协议又是什么概念？
在SDSN(Sat+SDN)的场景中，卫星与SDN是如何相互配合相互实现的？目前的研究领域和研究目标有哪些？技术难点和应用创新点有哪些？
针对上述知识，如何在技术上进行仿真与实现？

天体网络架构

整体工作可以大致切分为两块：系统架构（实验环境（当然也有可能是研究内容））+ SDN
系统架构大致可以分为几个部分：

1.网络层次关系设计

在这里插入图片描述
网络层次关系我个人的理解好像就是嘴上说说，大致就是整个系统应该是三个层面的事情，这里不提太多。

2.网络运行机制设计

运行机制是一个相对复杂的概念。设计到组网和控制域划分的问题，有很多不同的设计方向。

https://www.sdnlab.com/15853.html

这里就直接用一下别人论文里的定义：
在这里插入图片描述

3.卫星星体星座设计

卫星星座则是一个比较复杂的部分，常常通过覆盖性分析来确定整个的卫星星体结构。其构建过程可以参考铱星(Iridium)系统或者Walker星座。
例如：Starklink
SpaceX最初向FCC提交的报告里，Starlink是由4425颗分布在1100km高度轨道的LEO星座和7518颗分布在340km左右的VLEO（甚低轨）星座构成。具体分布参见表1和表2的星座轨道。
在这里插入图片描述
2018年底SpaceX又向FCC提交了修改计划，4月26日FCC宣布批准SpaceX调低其宽带星座项目部分卫星轨道的请求。将原1600颗1150km轨道卫星调整为1584颗550km的轨道卫星。通过降低部分卫星轨道，它所需卫星总数将可减少16颗，并将能让信号时延低至15毫秒。同时这将改善空间环境的安全性，因为轨道调低后的卫星即便不带推进，也会在报废后5年内再入地球大气层。
在这里插入图片描述
Starlink首先将实现1584颗550km的轨道卫星布置，实际发射时，由于火箭推力不够，卫星初始入轨点定为440km，后由推进器爬升至550km。知道1584颗卫星分布在24个平面，便比较容易用Walker星座设计器仿真出星座设计了。

其设计步骤如下

1）通过Space-track网站TLE根数分析出初始60颗卫星的轨道平面；根据发射日期和轨道倾角可以确定Starlink初始发射的60颗卫星国际编号为19029A至19029BM，NORAD编号为44235U至44294U，下载根数，导入STK；通过report分析J2000坐标系轨道升交点赤经

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L09SlS7n-1687513200531)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/b52c343b-649d-4f99-bbc9-cbcfc5f2f0d7/Untitled.png)]

2）设定种子卫星；本文以2019.05.27日根数分析结果，设定种子卫星历元及根数为：27 May 2019 06:14:00.000 UTC、半长轴6928.137（高度550km）、升交点赤经160°、轨道倾角53°、偏心率0°、其他轨道参数为0。为卫星添加传感器（Sensor）,设定圆锥半角为44.85°，为后续覆盖分析做准备。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K01fgAKJ-1687513200532)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/408da770-148c-4627-aa5f-a412622c519c/Untitled.png)]

3）由种子卫星生成参数（T/P/F）24/66/1的Walker星座，这里参数F暂取为1，具体应该怎么设置最优我没有搞明白，STK有Parametric Study Tool STK模块，但我没找到，如有了解者，敬请指导。这里为了美观，可以设置名称显示及轨道曲线等参数，不详细说明，注意为了后续分析方便，最好勾选创建星座，因为接下来覆盖分析可以通过星座选定分析卫星或是传感器，选择的时候种子卫星或其传感器不要选进去。同时算1584个目标计算机压力还是有点大的，试算可以使用较小规模的参数，比如（T/P/F）4/4/1
在这里插入图片描述

4.卫星网络拓扑设计

最后就是网络拓扑设计，在卫星星体确定的情况下，如何实现之前的卫星运行机制以及层次关系。简单来说，就是如何将SDN比较好的引入到设计的卫星星体上来。
目前有多种架构方式，参考如下：
在这里插入图片描述
例如设计一个两层的卫星网络：
如上图所示，LEO同样采用钵星体系，在LEO层面布置交换机，在MEO/GEO层面采用控制器部署
在地面控制中心部署控制器和MEO卫星来组成控制平面，为了简化网络模型，我们从逻辑上将多个地面控制中心视为一个整体的实体。LEO卫星层作为整个网络的基础设施层，负责数据包的转发。最初，每颗LEO卫星向其MEO卫星发送一个流表请求。MEO卫星在接收到流量表请求后，将收集到的信息发送到地面控制中心。地面控制中心计算不同的路由规则。
在这里插入图片描述
同样还有如上结构，采用了单一的控制器布置在GEO与全局相连，GEO层布置转发路由器承担部分转发功能，地面站则作为网络流量的输入层。

技术实现

在技术实现上，我主要参考了以下文章：

https://zhuanlan.zhihu.com/p/260657677
https://zhuanlan.zhihu.com/p/260657677)https://zhuanlan.zhihu.com/p/68385977
https://www.notion.so/SDN_SAT-79ebbc4f8aee4666a6b3b1208c683b21?pvs=4#9a4e85019d8a48cd9c62edd0ba0c0328

下面给出一段STK的单层结构与三层架构的参考代码，其中并没有具体给出LEO,MEO,GEO层的连接关系

import time
import json
from tqdm import tqdm

startTime = time.time()
from comtypes.gen import STKObjects, STKUtil, AgStkGatorLib
from comtypes.client import CreateObject, GetActiveObject, GetEvents, CoGetObject, ShowEvents
import requests
import time

"""
SET TO TRUE TO USE ENGINE, FALSE TO USE GUI
"""
useStkEngine = True
Read_Scenario = False
############################################################################
# Scenario Setup
############################################################################


if useStkEngine:
    # Launch STK Engine
    print("Launching STK Engine...")
    stkxApp = CreateObject("STKX11.Application")

    # Disable graphics. The NoGraphics property must be set to true before the root object is created.
    stkxApp.NoGraphics = True

    # Create root object
    stkRoot = CreateObject('AgStkObjects11.AgStkObjectRoot')

else:
    # Launch GUI
    print("Launching STK...")
    if not Read_Scenario:
        uiApp = CreateObject("STK11.Application")
    else:
        uiApp = GetActiveObject("STK11.Application")
    uiApp.Visible = True
    uiApp.UserControl = True

    # Get root object
    stkRoot = uiApp.Personality2

# Set date format
stkRoot.UnitPreferences.SetCurrentUnit("DateFormat", "UTCG")
# Create new scenario
print("Creating scenario...")
if not Read_Scenario:
    # stkRoot.NewScenario('Kuiper')
    stkRoot.NewScenario('StarLink')
scenario = stkRoot.CurrentScenario
scenario2 = scenario.QueryInterface(STKObjects.IAgScenario)
scenario2.StartTime = '24 Sep 2020 16:00:00.00'
scenario2.StopTime = '25 Sep 2020 16:20:00.00'
dt='24 Sep 2020 16:00:00'
ts = int(time.mktime(time.strptime(dt, "%d %b %Y %H:%M:%S")))


totalTime = time.time() - startTime
print("---Total time: {b:4.3f} sec ---".format(b=totalTime))


# 创建星座
def Creat_satellite(numOrbitPlanes=72, numSatsPerPlane=22, hight=550, Inclination=53, name='node_'):
    # Create constellation object
    print("--- create satellite ,total num :{a}    ---".format(a=numOrbitPlanes * numSatsPerPlane))
    constellation = scenario.Children.New(STKObjects.eConstellation, name)
    constellation2 = constellation.QueryInterface(STKObjects.IAgConstellation)

    # Insert the constellation of Satellites
    for orbitPlaneNum in range(numOrbitPlanes):  # RAAN in degrees
        print("---create sat on orbitPlane {a} ---".format(a=orbitPlaneNum))

        for satNum in range(numSatsPerPlane):  # trueAnomaly in degrees
            # Insert satellite
            satellite = scenario.Children.New(STKObjects.eSatellite, f"{name}{orbitPlaneNum}-{satNum}")
            satellite2 = satellite.QueryInterface(STKObjects.IAgSatellite)

            # Select Propagator
            satellite2.SetPropagatorType(STKObjects.ePropagatorTwoBody)

            # Set initial state
            twoBodyPropagator = satellite2.Propagator.QueryInterface(STKObjects.IAgVePropagatorTwoBody)
            keplarian = twoBodyPropagator.InitialState.Representation.ConvertTo(
                STKUtil.eOrbitStateClassical).QueryInterface(STKObjects.IAgOrbitStateClassical)
            #定义半轴长度
            keplarian.SizeShapeType = STKObjects.eSizeShapeSemimajorAxis
            #定义高度
            keplarian.SizeShape.QueryInterface(
                STKObjects.IAgClassicalSizeShapeSemimajorAxis).SemiMajorAxis = hight + 6371  # km
            #定义偏心率
            keplarian.SizeShape.QueryInterface(STKObjects.IAgClassicalSizeShapeSemimajorAxis).Eccentricity = 0

            keplarian.Orientation.Inclination = int(Inclination)  # degrees 倾角
            keplarian.Orientation.ArgOfPerigee = 0  # degrees 近地点
            keplarian.Orientation.AscNodeType = STKObjects.eAscNodeRAAN
            RAAN = 360 / numOrbitPlanes * orbitPlaneNum
            keplarian.Orientation.AscNode.QueryInterface(STKObjects.IAgOrientationAscNodeRAAN).Value = RAAN  # degrees

            keplarian.LocationType = STKObjects.eLocationTrueAnomaly
            trueAnomaly = 360 / numSatsPerPlane * satNum
            keplarian.Location.QueryInterface(STKObjects.IAgClassicalLocationTrueAnomaly).Value = trueAnomaly

            # Propagate
            satellite2.Propagator.QueryInterface(STKObjects.IAgVePropagatorTwoBody).InitialState.Representation.Assign(
                keplarian)
            satellite2.Propagator.QueryInterface(STKObjects.IAgVePropagatorTwoBody).Propagate()

            # Add to constellation object
            constellation2.Objects.AddObject(satellite)


# 为每个卫星加上发射机和接收机
def Add_transmitter_receiver(sat_list):
    print("--- add transmitter and reciver for sat ---")
    for each in sat_list:
        Instance_name = each.InstanceName
        #  new transmitter and receiver
        transmitter = each.Children.New(STKObjects.eTransmitter, "Transmitter_" + Instance_name)
        reciver = each.Children.New(STKObjects.eReceiver, "Reciver_" + Instance_name)
        #sensor = each.Children.New(STKObjects.eSensor, 'Sensor_' + Instance_name)


# 设置发射机参数
def Set_Transmitter_Parameter(transmitter, frequency=12, EIRP=20, DataRate=14):
    transmitter2 = transmitter.QueryInterface(STKObjects.IAgTransmitter)  # 建立发射机的映射，以便对其进行设置
    transmitter2.SetModel('Simple Transmitter Model')
    txModel = transmitter2.Model
    txModel = txModel.QueryInterface(STKObjects.IAgTransmitterModelSimple)
    txModel.Frequency = frequency  # GHz range:10.7-12.7GHz
    txModel.EIRP = EIRP  # dBW
    txModel.DataRate = DataRate  # Mb/sec


# 设置接收机参数
def Set_Receiver_Parameter(receiver, GT=20, frequency=12):
    receiver2 = receiver.QueryInterface(STKObjects.IAgReceiver)  # 建立发射机的映射，以便对其进行设置
    receiver2.SetModel('Simple Receiver Model')
    recModel = receiver2.Model
    recModel = recModel.QueryInterface(STKObjects.IAgReceiverModelSimple)
    recModel.AutoTrackFrequency = False
    recModel.Frequency = frequency  # GHz range:10.7-12.7GHz
    recModel.GOverT = GT  # dB/K
    return receiver2


# 获得接收机示例，并设置其参数
def Get_sat_receiver(sat, GT=20, frequency=12):
    receiver = sat.Children.GetElements(STKObjects.eReceiver)[0]  # 找到该卫星的接收机
    receiver2 = Set_Receiver_Parameter(receiver=receiver, GT=GT, frequency=frequency)
    return receiver2


def get_time():
    timeNow = time.strftime("%d %b %Y %H:%M:%S", time.localtime(ts))
    timeNowLong = str(timeNow) + ".00"
    return timeNowLong



# 计算传输链路
def Compute_access(access):
    # print("---computer access---")
    access.ComputeAccess()
    accessDP = access.DataProviders.Item('Link Information')
    accessDP2 = accessDP.QueryInterface(STKObjects.IAgDataPrvTimeVar)
    Elements = ["Range"]
    results = accessDP2.ExecSingleElements(get_time(), Elements)
    # results2 = accessDP2.ExecSingleElements(scenario2.StopTime, Elements)
    # Times = results.DataSets.GetDataSetByName('Time').GetValues()  # 时间
    # EbNo = results.DataSets.GetDataSetByName('Eb/No').GetValues()  # 码元能量
    # BER = results.DataSets.GetDataSetByName('BER').GetValues()  # 误码率
    # Link_Name = results.DataSets.GetDataSetByName('Link Name').GetValues()
    # Prop_Loss = results.DataSets.GetDataSetByName('Prop Loss').GetValues()
    # Xmtr_Gain = results.DataSets.GetDataSetByName('Xmtr Gain').GetValues()
    # EIRP = results.DataSets.GetDataSetByName('EIRP').GetValues()

    Range = results.DataSets.GetDataSetByName('Range').GetValues()
    # Range2=results2.DataSets.GetDataSetByName('Range').GetValues()
    # print(results2)
    return Range


def Creating_All_Access():
    # 首先清空场景中所有的链接
    print('--- Clearing All Access ---')
    print('--- create Access ---')
    stkRoot.ExecuteCommand('RemoveAllAccess /')

    # 计算某个卫星与其通信的四颗卫星的链路质量，并生成报告
    for each_sat in sat_list:
        now_sat_name = each_sat.InstanceName
        now_plane_num = int(now_sat_name.split('-')[0][5:])
        now_sat_num = int(now_sat_name.split('-')[1])
        now_sat_transmitter = each_sat.Children.GetElements(STKObjects.eTransmitter)[0]  # 找到该卫星的发射机
        Set_Transmitter_Parameter(now_sat_transmitter, EIRP=20)
        # 发射机与接收机相连
        # 与后面的卫星的接收机相连
        B_Name = sat_dic['node_' + str(now_plane_num) + '-' + str((now_sat_num + 1) % 10)].InstanceName
        F_Name = sat_dic['node_' + str(now_plane_num) + '-' + str((now_sat_num - 1) % 10)].InstanceName
        L_Name = sat_dic['node_' + str((now_plane_num - 1) % 10) + '-' + str(now_sat_num)].InstanceName
        R_Name = sat_dic['node_' + str((now_plane_num + 1) % 10) + '-' + str(now_sat_num)].InstanceName
        access_backward = now_sat_transmitter.GetAccessToObject(
            Get_sat_receiver(sat_dic['node_' + str(now_plane_num) + '-' + str((now_sat_num + 1) % 10)]))
        # 与前面的卫星的接收机相连
        access_forward = now_sat_transmitter.GetAccessToObject(
            Get_sat_receiver(sat_dic['node_' + str(now_plane_num) + '-' + str((now_sat_num - 1) % 10)]))
        # 与左面的卫星的接收机相连
        access_left = now_sat_transmitter.GetAccessToObject(
            Get_sat_receiver(sat_dic['node_' + str((now_plane_num - 1) % 10) + '-' + str(now_sat_num)]))
        # 与右面的卫星的接收机相连
        access_right = now_sat_transmitter.GetAccessToObject(
            Get_sat_receiver(sat_dic['node_' + str((now_plane_num + 1) % 10) + '-' + str(now_sat_num)]))
        B_Range = Compute_access(access_backward)
        F_Range = Compute_access(access_forward)
        L_Range = Compute_access(access_left)
        R_Range = Compute_access(access_right)
        B_Dict = {'node1': now_sat_name, 'node2': B_Name, 'bw': 20, 'delay': str(int(B_Range[0] / 300))+'ms', 'jitter': '1ms',
                  'loss': 0}
        F_Dict = {'node1': now_sat_name, 'node2': F_Name, 'bw': 20,
                  'delay': str(int(F_Range[0] / 300))+'ms', 'jitter': '1ms','loss': 0}
        L_Dict = {'node1': now_sat_name, 'node2': L_Name, 'bw': 20, 'delay': str(int(L_Range[0] / 300))+'ms', 'jitter': '1ms',
                   'loss': 0}
        R_Dict = {'node1': now_sat_name, 'node2': R_Name, 'bw': 20, 'delay':str(int(R_Range[0] / 300))+'ms', 'jitter': '1ms',
                   'loss': 0}
        data_list.append(B_Dict)
        data_list.append(F_Dict)
        #data_list.append(L_Dict)
        #data_list.append(R_Dict)
        # print('{0}\r', B_Range, F_Range, L_Range, R_Range)
    # stkRoot.ExecuteCommand('RemoveAllAccess /')


def Change_Sat_color(sat_list):
    # 修改卫星及其轨道的颜色
    print('Changing Color of Satellite')
    for each_sat in sat_list:
        now_sat_name = each_sat.InstanceName
        now_plane_num = int(now_sat_name.split('_')[0][3:])
        now_sat_num = int(now_sat_name.split('_')[1])
        satellite = each_sat.QueryInterface(STKObjects.IAgSatellite)
        graphics = satellite.Graphics
        graphics.SetAttributesType(1)  # eAttributesBasic
        attributes = graphics.Attributes
        attributes_color = attributes.QueryInterface(STKObjects.IAgVeGfxAttributesBasic)
        attributes_color.Inherit = False
        # 16436871 浅蓝色
        # 2330219 墨绿色
        # 42495 橙色
        # 9234160 米黄色
        # 65535 黄色
        # 255 红色
        # 16776960 青色
        color_sheet = [16436871, 2330219, 42495, 9234160, 65535, 255, 16776960]
        if now_sat_name[2] == 'A':
            color = 255
        elif now_sat_name[2] == 'B':
            color = 42495
        elif now_sat_name[2] == 'C':
            color = 16436871
        attributes_color.Color = color
        # 找出轨道对应的属性接口
        orbit = attributes.QueryInterface(STKObjects.IAgVeGfxAttributesOrbit)
        orbit.IsOrbitVisible = False  # 将轨道设置为不可见

def mid_link():
    for each_sat in sat_list:
        now_sat_name = each_sat.InstanceName
        tmpparam={'node1': now_sat_name, 'node2': "mid1", 'bw': 20, 'delay': "20ms", 'jitter': '1ms',
                  'loss': 0}
        data_list.append(tmpparam)



# 如果不是读取当前场景，即首次创建场景
if not Read_Scenario:
    Creat_satellite(numOrbitPlanes=10, numSatsPerPlane=10, hight=550, Inclination=53)  # Starlink
    # Kuiper
    # Creat_satellite(numOrbitPlanes=34, numSatsPerPlane=34, hight=630, Inclination=51.9, name='KPA')  # Phase A
    # Creat_satellite(numOrbitPlanes=32, numSatsPerPlane=32, hight=610, Inclination=42, name='KPB')  # Phase B
    #Creat_satellite(numOrbitPlanes=28, numSatsPerPlane=28, hight=590, Inclination=33)  # Phase C
    sat_list = stkRoot.CurrentScenario.Children.GetElements(STKObjects.eSatellite)
    Add_transmitter_receiver(sat_list)

# 创建卫星的字典，方便根据名字对卫星进行查找
sat_list = stkRoot.CurrentScenario.Children.GetElements(STKObjects.eSatellite)
sat_dic = {}
data_list = []
print('--- Creating Satellite Dictionary ---')
for sat in sat_list:
    sat_dic[sat.InstanceName] = sat
Plane_num = []
for i in range(0, 10):
    Plane_num.append(i)
Sat_num = []
for i in range(0, 10):
    Sat_num.append(i)

headers = {
    "Content-Type": "application/json;charset=utf8"
}
for i in range(0,10):
    Creating_All_Access()
    ts+=600
    print(data_list)
    data_list = json.dumps(data_list)
    response = requests.post('http://192.168.56.135:8000/modify/', data = data_list,headers=headers)
    print("--- topo uptade ---")
    data_list = []
    if i==0:
        mid_link()
        data_list = json.dumps(data_list)
        print(data_list)
        response = requests.post('http://192.168.56.135:8000/modify/', data = data_list,headers=headers)
    print(i)
    time.sleep(30)
print("end")

def Creating_All_Access():
    # 首先清空场景中所有的链接
    print('--- Clearing All Access ---')
    print('--- create Access ---')
    stkRoot.ExecuteCommand('RemoveAllAccess /')

    # 计算某个卫星与其通信的四颗卫星的链路质量，并生成报告
    for each_sat in sat_list:
        now_sat_name = each_sat.InstanceName
        print(now_sat_name)
        now_plane_num = int(now_sat_name.split('-')[0][4:])
        now_sat_num = int(now_sat_name.split('-')[1])
        now_plane_name = (now_sat_name.split(' ')[0][:4])
        now_sat_transmitter = each_sat.Children.GetElements(STKObjects.eTransmitter)[0]  # 找到该卫星的发射机
        Set_Transmitter_Parameter(now_sat_transmitter, EIRP=20)
        # 发射机与接收机相连
        # 与后面的卫星的接收机相连
        if(now_plane_name == 'LEO_'):
            numOrbitPlanes = 6
            numSatsPerPlane = 12
            B_Name = sat_dic['LEO_' + str(now_plane_num) + '-' + str((now_sat_num + 1) % numSatsPerPlane)].InstanceName
            F_Name = sat_dic['LEO_' + str(now_plane_num) + '-' + str((now_sat_num - 1) % numSatsPerPlane)].InstanceName
            # L_Name = sat_dic['LEO_' + str((now_plane_num - 1) % numOrbitPlanes) + '-' + str(now_sat_num)].InstanceName
            # R_Name = sat_dic['LEO_' + str((now_plane_num + 1) % numOrbitPlanes) + '-' + str(now_sat_num)].InstanceName
            access_backward = now_sat_transmitter.GetAccessToObject(
                Get_sat_receiver(sat_dic['LEO_' + str(now_plane_num) + '-' + str((now_sat_num + 1) % numSatsPerPlane)]))
            # 与前面的卫星的接收机相连
            access_forward = now_sat_transmitter.GetAccessToObject(
                Get_sat_receiver(sat_dic['LEO_' + str(now_plane_num) + '-' + str((now_sat_num - 1) % numSatsPerPlane)]))
            # 与左面的卫星的接收机相连
            # access_left = now_sat_transmitter.GetAccessToObject(
            #    Get_sat_receiver(sat_dic['node_' + str((now_plane_num - 1) % numOrbitPlanes) + '-' + str(now_sat_num)]))
            # 与右面的卫星的接收机相连
            # access_right = now_sat_transmitter.GetAccessToObject(
            #    Get_sat_receiver(sat_dic['node_' + str((now_plane_num + 1) % numOrbitPlanes) + '-' + str(now_sat_num)]))
            B_Range = Compute_access(access_backward)
            F_Range = Compute_access(access_forward)
            # L_Range = Compute_access(access_left)
            # R_Range = Compute_access(access_right)
            B_Dict = {'node1': now_sat_name, 'node2': B_Name, 'bw': 20, 'delay': str(int(B_Range[0] / 300)) + 'ms',
                      'jitter': '1ms',
                      'loss': 0}
            F_Dict = {'node1': now_sat_name, 'node2': F_Name, 'bw': 20,
                      'delay': str(int(F_Range[0] / 300)) + 'ms', 'jitter': '1ms', 'loss': 0}
            # L_Dict = {'node1': now_sat_name, 'node2': L_Name, 'bw': 20, 'delay': str(int(L_Range[0] / 300))+'ms', 'jitter': '1ms',
            #           'loss': 0}
            # R_Dict = {'node1': now_sat_name, 'node2': R_Name, 'bw': 20, 'delay':str(int(R_Range[0] / 300))+'ms', 'jitter': '1ms',
            #           'loss': 0}
            data_list.append(B_Dict)
            data_list.append(F_Dict)
            # data_list.append(L_Dict)
            # data_list.append(R_Dict)
        elif(now_plane_name == 'MEO_'):
            numOrbitPlanes = 3
            numSatsPerPlane = 9
            B_Name = sat_dic['MEO_' + str(now_plane_num) + '-' + str((now_sat_num + 1) % numSatsPerPlane)].InstanceName
            F_Name = sat_dic['MEO_' + str(now_plane_num) + '-' + str((now_sat_num - 1) % numSatsPerPlane)].InstanceName
            # L_Name = sat_dic['MEO_' + str((now_plane_num - 1) % numOrbitPlanes) + '-' + str(now_sat_num)].InstanceName
            # R_Name = sat_dic['MEO_' + str((now_plane_num + 1) % numOrbitPlanes) + '-' + str(now_sat_num)].InstanceName
            access_backward = now_sat_transmitter.GetAccessToObject(
                Get_sat_receiver(sat_dic['MEO_' + str(now_plane_num) + '-' + str((now_sat_num + 1) % numSatsPerPlane)]))
            # 与前面的卫星的接收机相连
            access_forward = now_sat_transmitter.GetAccessToObject(
                Get_sat_receiver(sat_dic['MEO_' + str(now_plane_num) + '-' + str((now_sat_num - 1) % numSatsPerPlane)]))
            # 与左面的卫星的接收机相连
            # access_left = now_sat_transmitter.GetAccessToObject(
            #    Get_sat_receiver(sat_dic['MEO_' + str((now_plane_num - 1) % numOrbitPlanes) + '-' + str(now_sat_num)]))
            # 与右面的卫星的接收机相连
            # access_right = now_sat_transmitter.GetAccessToObject(
            #    Get_sat_receiver(sat_dic['MEO_' + str((now_plane_num + 1) % numOrbitPlanes) + '-' + str(now_sat_num)]))
            B_Range = Compute_access(access_backward)
            F_Range = Compute_access(access_forward)
            # L_Range = Compute_access(access_left)
            # R_Range = Compute_access(access_right)
            B_Dict = {'meo1': now_sat_name, 'meo2': B_Name, 'bw': 20, 'delay': str(int(B_Range[0] / 300)) + 'ms',
                      'jitter': '1ms',
                      'loss': 0}
            F_Dict = {'meo1': now_sat_name, 'meo2': F_Name, 'bw': 20,
                      'delay': str(int(F_Range[0] / 300)) + 'ms', 'jitter': '1ms', 'loss': 0}
            # L_Dict = {'meo1': now_sat_name, 'meo2': L_Name, 'bw': 20, 'delay': str(int(L_Range[0] / 300))+'ms', 'jitter': '1ms',
            #           'loss': 0}
            # R_Dict = {'meo1': now_sat_name, 'meo2': R_Name, 'bw': 20, 'delay':str(int(R_Range[0] / 300))+'ms', 'jitter': '1ms',
            #           'loss': 0}
            data_list.append(B_Dict)
            data_list.append(F_Dict)
            # data_list.append(L_Dict)
            # data_list.append(R_Dict)
        elif (now_plane_name == 'GEO_'):
            numOrbitPlanes = 3
            numSatsPerPlane = 1

SDN

在SDN部分的研究则相当的广泛了，之前给到的参考资料中可以提供很多的借鉴，后续有时间的话会出一下自己对于RYU控制器的理解以及一些相关功能的实现。基础的知识也就不做太多介绍了。
这里主要分享一下STK与Mininet进行连接以及json数据传输：
大体思路就是利用Falsk将STK的卫星拓扑参数传递给Mininet,Mininet通过读取的轨道参数进行交换机与控制器的构建。以下的代码仅供参考，根据实际情况进行修改即可。

if __name__ == "__main__":
    setLogLevel("info")
    OVSKernelSwitch.setup() //开启一个网络
    intfName_1 = "eth2"     //将虚拟机eth2赋值给为变量intfName_1
    intfName_3 = "eth3"
    info("****checking****", intfName_1, '\n')
    checkIntf(intfName_1)    //检查是否可用
    info("****checking****", intfName_3, '\n')
    checkIntf(intfName_3)

    info("****creating network****\n")
    net = Mininet(listenPort = 6633)   //创建一个Mininet的实例，端口为6633

    mycontroller = RemoteController("muziController",   ip = "192.168.0.1")//创建远程控制器，ip=192.168.0.1，端口是6633。

    switch_1 = net.addSwitch('s1')   //在net里添加交换机s1,mininet中规则为：如果不填充dpid参数，则dpid参数默认取sn的n.即s1的dpid为1。
    switch_2 = net.addSwitch('s2')
    switch_3 = net.addSwitch('s3')
    switch_4 = net.addSwitch('s4')

    net.controllers = [mycontroller] //将远程控制器添加到网络中


    net.addLink(switch_1, switch_2, 2, 1)# node1,   node2, port1, port2net.addLink(switch_2, switch_3, 2, 1)//将s2的2端口跟s3的1端口连接起来。（物理连接）
    net.addLink(switch_1, switch_4, 3, 1)


    //需要注意的是，以上连接的链路是一个环形的链路，在没有解决风暴的情况下，会出问题。
    info("*****Adding hardware interface ",     intfName_1, "to switch:" ,switch_1.name, '\n')
    info("*****Adding hardware interface ",     intfName_3, "to switch:" ,switch_3.name, '\n')

    _intf_1 = Intf(intfName_1, node = switch_1, port =  1)//将intfName_1和s1的端口1相连，形成一个接口_intf_1
    _intf_3 = Intf(intfName_3, node = switch_3, port =  2)

    net.addLink(switch_4, switch_3, 2, 3)//为什么放在这里呢？因为mininet中允许的端口分配方式是从小到大分配，所以，s3的3端口的配置应该放在s3的2端口之后，虽然难看，但是必须这么做，当然你也可以从新分配端口，只要保证端口是从小到大分配就好了。

    info("Node: you may need to reconfigure the     interfaces for the Mininet hosts:\n",   net.hosts, '\n')

    net.start()  //启动net
    CLI(net)     //等待键入命令
    net.stop()   //关闭net

# mininet/mininet/custom/modify_Link.py
from mininet.net import Mininet
from typing import Dict
import time

//对于当前node_n_m 得到node_(n+1)_(m+1)
def get_next(n, m, n_max, m_max):
    n_ = (n+1)%n_max
    m_ = (m+1)%m_max
    return n_, m_

//修正Link，用于动态星体时需要修改链路情况时使用
def modifyLink(net:Mininet, node1:str, node2:str, params1:Dict, params2:Dict=None):
    """

    利用params1和params2设置属性连接node1和node2的连接的属性，
    params1控制node1对应的intf
    params2控制node2对应的intf，若缺省则通params1


    参考 mininet.link.TCIntf.config()


    params1和params2的键值参考下面

    for all Intf:
        mac=None, 
        ip=None, 
        ifconfig=None,
        up=True

    only for TCIntf:
           bw: bandwidth in b/s (e.g. '10m')
           delay: transmit delay (e.g. '1ms' )
           jitter: jitter (e.g. '1ms')
           loss: loss (e.g. '1%' )
           gro: enable GRO (False)
           txo: enable transmit checksum offload (True)
           rxo: enable receive checksum offload (True)
           speedup: experimental switch-side bw option
           use_hfsc: use HFSC scheduling
           use_tbf: use TBF scheduling
           latency_ms: TBF latency parameter
           enable_ecn: enable ECN (False)
           enable_red: enable RED (False)
           max_queue_size: queue limit parameter for netem
    """
    h1 = net.getNodeByName( node1 )
    h2 = net.getNodeByName( node2 )

    links = h1.connectionsTo(h2)

    srcIntf = links[0][0]  # todo 判断有没有写错
    dstIntf = links[0][1]


    if not params2:
        #* 如果只修改node1，设置params2为非空字典，且不包含上面提到的参数
        params2 = params1
    srcIntf.config(**params1)
    dstIntf.config(**params2)


def modifyNode(net:Mininet, node1:str, node2:str, params1:Dict):
    """
    modify intf of node1 that is linked to node2
    parameters are in modifyLink()

    for all Intf:
        mac=None, 
        ip=None, 
        ifconfig=None,
        up=True
    """
    modifyLink(net, node1, node2, params1, params2=None)

//设置ip_table
def set_ip_table(net, node1, node2):
    h1 = net.getNodeByName( node1 )
    h2 = net.getNodeByName( node2 )

    links = h1.connectionsTo(h2)

    Intf1 = links[0][0]
    Intf2 = links[0][1]

    ip1 = Intf1.IP()
    ip2 = Intf2.IP()

    name1 = Intf1.name
    name2 = Intf2.name

    h1.cmd(f'ip r del 10.0.0.0/8 dev {name1}')
    # time.sleep(0.5)
    command = f'ip r add {ip2}/32 dev {name1} src {ip1}'
    h1.cmd(command)
    # time.sleep(0.5)
    print(f'{node1}--->{command}')

    h2.cmd(f'ip r del 10.0.0.0/8 dev {name2}')
    # time.sleep(0.5)
    command = f'ip r add {ip1}/32 dev {name2} src {ip2}'
    h2.cmd(command)
    print(f'{node2}--->{command}')

其中config文件：

```python
n = 5
m = 5


# 同轨道默认参数
bw = 100
delay = '5ms'
jitter = '1ms'
loss = 0


# 与中继卫星默认参数
mid_bw = 100
mid_delay = '80ms'
mid_jitter = '5ms'
mid_loss = 0