Python write_json_file Beispiele

Beispiel #1

Datei: dvbt2_37_modes_supplument_3_fft_pilot.py Projekt: invictus86/front_end_code

    [MODULATION_256QAM, CODE_RATE_2_3, "M32K", "PP4", 62, GUARD_G1_16, None],
    [MODULATION_256QAM, CODE_RATE_2_3, "M16K", "PP5", 90, GUARD_G1_16, None],
    [MODULATION_256QAM, CODE_RATE_3_4, "M32K", "PP6", 62, GUARD_G1_32, None],
    [MODULATION_256QAM, CODE_RATE_3_4, "M32K", "PP7", 60, GUARD_G1_128, None],
    [MODULATION_256QAM, CODE_RATE_3_4, "M32K", "PP8", 62, GUARD_G1_16, None]
]

my_file = Path("../../ekt_json/dvbt2_37_modes_supplument_3_fft_pilot.json")
if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    dict_test_parame_result[
        "test_parame_result"] = FFTSIZE_PIL_LEVEL_GUARD_LIST
    write_json_file(
        "../../ekt_json/dvbt2_37_modes_supplument_3_fft_pilot.json",
        dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file(
        "../../ekt_json/dvbt2_37_modes_supplument_3_fft_pilot.json")
    sfu_ip = ekt_cfg.SFU_IP

Beispiel #2

Datei: dvbt_20_performance_0db_echo_channel.py Projekt: invictus86/front_end_code

        [FFT_SIZE_8K, MODULATION_16QAM, CODE_RATE_2_3, GUARD_G1_4, 17.9, None],
        [FFT_SIZE_8K, MODULATION_16QAM, CODE_RATE_3_4, GUARD_G1_4, 22.1, None],
        [FFT_SIZE_8K, MODULATION_64QAM, CODE_RATE_1_2, GUARD_G1_4, 19.0, None],
        [FFT_SIZE_8K, MODULATION_64QAM, CODE_RATE_2_3, GUARD_G1_8, 23.2, None],
        [FFT_SIZE_8K, MODULATION_64QAM, CODE_RATE_2_3, GUARD_G1_4, 23.2, None],
        [FFT_SIZE_8K, MODULATION_64QAM, CODE_RATE_3_4, GUARD_G1_4, 27.6, None]]
     ]
]

my_file = Path("../../ekt_json/dvbt_20_performance_0db_echo_channel.json")
if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    dict_test_parame_result["test_parame_result"] = PARAMETER_LIST
    write_json_file("../../ekt_json/dvbt_20_performance_0db_echo_channel.json",
                    dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file("../../ekt_json/dvbt_20_performance_0db_echo_channel.json")
    sfu_ip = ekt_cfg.SFU_IP
    specan = Ektsfu(sfu_ip)
    specan.preset_instrument()

Beispiel #3

Datei: dvbt_25_analogue_singnal_other_channel.py Projekt: invictus86/front_end_code

my_file = Path("../../ekt_json/dvbt_25_analogue_singnal_other_channel.json")
if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    list_test_parame_result = []

    for FREQUENCY in FREQUENCY_LIST:
        list_test_result = []
        for PARAMETER in PARAMETER_LIST:
            list_test_result.append(
                [PARAMETER[0], PARAMETER[1], PARAMETER[2], PARAMETER[3], PARAMETER[4]])
        list_test_parame_result.append([FREQUENCY[0], FREQUENCY[1], list_test_result])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result
    write_json_file("../../ekt_json/dvbt_25_analogue_singnal_other_channel.json",
                    dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file("../../ekt_json/dvbt_25_analogue_singnal_other_channel.json")
    sfu_ip = ekt_cfg.SFU_IP
    specan = Ektsfu(sfu_ip)
    specan.preset_instrument()

Beispiel #4

else:
    dict_test_parame_result = {}
    list_test_parame_result = []

    dict_data = read_ekt_config_data("../../ekt_lib/ekt_config.json")
    DVBS2_8PSK_CODE_RATE_CN = dict_data.get("DVBS2_8PSK_CODE_RATE_CN")

    for SYMBOL_RATE in dict_config_data.get("SYMBOL_RATE"):
        list_test_result = []
        for code_rate_cn in DVBS2_8PSK_CODE_RATE_CN:
            list_test_result.append([code_rate_cn, None])

        list_test_parame_result.append([SYMBOL_RATE, list_test_result])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result

    write_json_file("../../ekt_json/dvbs2_24_symbol_err_rate.json",
                    dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置modulation,symbol_rate,code_rate,frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file("../../ekt_json/dvbs2_24_symbol_err_rate.json")
    sfu_ip = ekt_cfg.SFU_IP
    specan = Ektsfu(sfu_ip)
    specan.preset_instrument()

Beispiel #5

Datei: dvbc_7_analogue_adjacent_carrier_interference_N-1.py Projekt: invictus86/front_end_code

if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    list_test_parame_result = []

    for PARAMETER in PARAMETER_LIST:
        list_test_result = []
        for FREQUENCY in FREQUENCY_LIST:
            list_test_result.append([FREQUENCY, None])
        list_test_parame_result.append(
            [PARAMETER[0], PARAMETER[1], PARAMETER[2], list_test_result])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result

    write_json_file(
        "../../ekt_json/dvbc_7_analogue_adjacent_carrier_interference.json",
        dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置modulation,symbol_rate, CN, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file(
        "../../ekt_json/dvbc_7_analogue_adjacent_carrier_interference.json")
    sfu_ip = ekt_cfg.SFU_IP

Beispiel #6

my_file = Path("../../ekt_json/dvbs2_23_amplitude_distortion_test.json")
if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    list_test_parame_result = []
    for SYMBOL_RATE in SYMBOL_RATE_LIST:
        for FREQUENCY_LEVEL_OFFSET in FREQUENCY_LEVEL_OFFSET_LIST:
            list_test_result = []
            for code_rate in CODE_RATE_LIST:
                list_test_result.append([code_rate, None])
            list_test_parame_result.append(
                [SYMBOL_RATE, FREQUENCY_LEVEL_OFFSET, list_test_result])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result
    write_json_file("../../ekt_json/dvbs2_23_amplitude_distortion_test.json",
                    dict_test_parame_result)

if __name__ == '__main__':
    """
   测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置modulation,symbol_rate,code_rate,frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
   """
    load_dict = read_json_file(
        "../../ekt_json/dvbs2_23_amplitude_distortion_test.json")
    sfu_ip = ekt_cfg.SFU_IP
    specan = Ektsfu(sfu_ip)

Beispiel #7

Datei: dvbc_10_frequency_capture_range.py Projekt: invictus86/front_end_code

my_file = Path("../../ekt_json/dvbc_10_frequency_capture_range.json")
if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    list_test_parame_result = []

    for SYMBOL_RATE in SYMBOL_RATE_LIST:
        for REQUENCY in REQUENCY_LIST:
            list_test_result = []
            for MODULATION in MODULATION_LIST:
                list_test_result.append([MODULATION, None])
            list_test_parame_result.append([SYMBOL_RATE, REQUENCY, list_test_result])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result

    write_json_file("../../ekt_json/dvbc_10_frequency_capture_range.json", dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置modulation,symbol_rate, CN, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file("../../ekt_json/dvbc_10_frequency_capture_range.json")
    sfu_ip = ekt_cfg.SFU_IP
    specan = Ektsfu(sfu_ip)
    specan.preset_instrument()

Beispiel #8

Datei: dvbt2_44_normal_mode.py Projekt: invictus86/front_end_code

GUARD_G1_4 = "G1_4"

KE32 = "M32E"
KN32 = "M32K"
PARAMETER_LIST = [[
    FREQUENCY_666, LEVEL_OFFSET_666, LEVEL_50_666, 8, KE32, MODULATION_256QAM,
    "PP4", CODE_RATE_2_3, GUARD_G1_16, None
]]

my_file = Path("../../ekt_json/dvbt2_44_normal_mode.json")
if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    dict_test_parame_result["test_parame_result"] = PARAMETER_LIST
    write_json_file("../../ekt_json/dvbt2_44_normal_mode.json",
                    dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file("../../ekt_json/dvbt2_44_normal_mode.json")
    sfu_ip = ekt_cfg.SFU_IP
    specan = Ektsfu(sfu_ip)
    specan.preset_instrument()

Beispiel #9

                     [290.0, 8, None], [296.5, 8, None], [298.0, 8, None],
                     [306.0, 8, None], [314.0, 8, None], [322.0, 8, None],
                     [330.0, 8, None], [338.0, 8, None], [346.0, 8, None],
                     [354.0, 8, None], [362.0, 8, None], [370.0, 8, None],
                     [378.0, 8, None], [386.0, 8, None], [394.0, 8, None],
                     [402.0, 8, None], [410.0, 8, None], [418.0, 8, None],
                     [426.0, 8, None], [434.0, 8, None], [442.0, 8, None],
                     [450.0, 8, None], [458.0, 8, None], [466.0, 8, None]]

my_file = Path("../../ekt_json/dvbt2_34_centre_frequencies.json")
if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    dict_test_parame_result["test_parame_result"] = FREQUENCY_BW_LIST
    write_json_file("../../ekt_json/dvbt2_34_centre_frequencies.json",
                    dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file(
        "../../ekt_json/dvbt2_34_centre_frequencies.json")
    sfu_ip = ekt_cfg.SFU_IP
    specan = Ektsfu(sfu_ip)

Beispiel #10

my_file = Path(
    "../../ekt_json/dvbt_13_verification_signal_strength_indicator_ssi.json")
if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    list_test_parame_result = []

    for PARAMETER in PARAMETER_LIST:
        list_test_result = []
        for LEVEL in LEVEL_LIST:
            list_test_result.append([LEVEL, None])
        list_test_parame_result.append([PARAMETER, list_test_result])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result
    write_json_file(
        "../../ekt_json/dvbt_13_verification_signal_strength_indicator_ssi.json",
        dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file(
        "../../ekt_json/dvbt_13_verification_signal_strength_indicator_ssi.json"
    )

Beispiel #11

Datei: j83_8_symbol_error_rate.py Projekt: invictus86/front_end_code

if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    list_test_parame_result = []

    for SYMBOL_RATE in SYMBOL_RATE_LIST:
        for REQUENCY in REQUENCY_LIST:
            list_test_result = []
            for MODULATION in MODULATION_LIST:
                list_test_result.append([MODULATION, None])
            list_test_parame_result.append(
                [SYMBOL_RATE, REQUENCY, list_test_result])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result

    write_json_file("../../ekt_json/j83_8_symbol_error_rate.json",
                    dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置modulation,symbol_rate, CN, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file("../../ekt_json/j83_8_symbol_error_rate.json")
    sfu_ip = ekt_cfg.SFU_IP
    specan = Ektsfu(sfu_ip)
    specan.preset_instrument()

Beispiel #12

        if FREQUENCY_LEVEL_OFFSET[0] < 400:
            CURRENT_MODULATION__CODERATE_SPEC_LIST = MODULATION_CODERATE_7M_SPEC_LIST
        else:
            CURRENT_MODULATION__CODERATE_SPEC_LIST = MODULATION_CODERATE_8M_SPEC_LIST

        for MODULATION_CODERATE_SPEC in CURRENT_MODULATION__CODERATE_SPEC_LIST:
            list_test_result.append([
                MODULATION_CODERATE_SPEC[0], MODULATION_CODERATE_SPEC[1],
                MODULATION_CODERATE_SPEC[2], None, None
            ])
        list_test_parame_result.append(
            [FREQUENCY_LEVEL_OFFSET, list_test_result])

    dict_test_parame_result["test_parame_result"] = list_test_parame_result
    write_json_file(
        "../../ekt_json/dvbt2_59_receiver_signal_input__min_level.json",
        dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    # 将部分无需测试的点的json文件内容, 测试结果置为 NO NEED TEST
    dvbt2_57_gaussian_channel_json_class_test(
        "../../ekt_json/dvbt2_59_receiver_signal_input__min_level.json")

Beispiel #13

else:
    dict_test_parame_result = {}
    list_test_parame_result = []

    for FREQUENCY in FREQUENCY_LIST:
        list_test_result = []
        for PARAMETER in PARAMETER_LIST:
            list_test_result.append([
                PARAMETER[0], PARAMETER[1], PARAMETER[2], PARAMETER[3],
                PARAMETER[4], PARAMETER[5]
            ])
        list_test_parame_result.append(
            [FREQUENCY[0], FREQUENCY[1], FREQUENCY[2], list_test_result])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result
    write_json_file(
        "../../ekt_json/dvbt_28_co_channek_interference_analogue.json",
        dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file(
        "../../ekt_json/dvbt_28_co_channek_interference_analogue.json")
    sfu_ip = ekt_cfg.SFU_IP

Beispiel #14

Datei: dvbt2_35_frequency_offset.py Projekt: invictus86/front_end_code

LEVEL_60 = "-60"

FREQUENCY_BW_OFFSET_LIST = [[177, 7, -0.05, None], [177, 7, 0, None],
                            [177, 7, +0.05, None], [226, 7, -0.05, None],
                            [226, 7, 0, None], [226, 7, +0.05, None],
                            [474, 8, -0.05, None], [474, 8, 0, None],
                            [474, 8, +0.05, None], [858, 8, -0.05, None],
                            [858, 8, 0, None], [858, 8, +0.05, None]]

my_file = Path("../../ekt_json/dvbt2_35_frequency_offset.json")
if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    dict_test_parame_result["test_parame_result"] = FREQUENCY_BW_OFFSET_LIST
    write_json_file("../../ekt_json/dvbt2_35_frequency_offset.json",
                    dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file("../../ekt_json/dvbt2_35_frequency_offset.json")
    sfu_ip = ekt_cfg.SFU_IP
    specan = Ektsfu(sfu_ip)
    specan.preset_instrument()

Beispiel #15

Datei: dvbs_12_symbol_rate_step.py Projekt: invictus86/front_end_code

LEVEL_OFFSET = find_level_offset_by_frequency("DVBS_S2_FREQUENCY_LEVEL_OFFSET",
                                              int(FREQUENCY_1550))
LEVEL_70 = str("%.2f" % ((-70) - LEVEL_OFFSET))

SYMBOL_RATE_LIST = generate_symbol_rate_list()

my_file = Path("../../ekt_json/dvbs_12_symbol_rate_step.json")
if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    list_test_parame_result = []
    for SYMBOL_RATE in SYMBOL_RATE_LIST:
        list_test_parame_result.append([SYMBOL_RATE, None])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result
    write_json_file("../../ekt_json/dvbs_12_symbol_rate_step.json",
                    dict_test_parame_result)


def sfe_init_setting():
    """
    sfe init setting
    :return:
    """
    sfe_ip = ekt_cfg.SFE_IP
    specan = Ektsfe(sfe_ip)
    specan.clean_reset()
    specan = Ektsfe(sfe_ip)
    specan.preset_instrument()
    specan = Ektsfe(sfe_ip)
    specan.set_digitaltv_input_source("TSPL")
    specan = Ektsfe(sfe_ip)

Beispiel #16

Datei: dvbt2_69_performance_in_SFN_inside_guard.py Projekt: invictus86/front_end_code

    for PARAMETER in PARAMETER_LIST:
        list_test_result = []
        for FADING in PARAMETER[10]:
            list_result = []
            for LOSS in FADING_LOSS:
                list_result.append(LOSS)
            list_test_result.append(
                [FADING[0], FADING[1], FADING[2], list_result])
        list_test_parame_result.append([
            PARAMETER[0], PARAMETER[1], PARAMETER[2], PARAMETER[3],
            PARAMETER[4], PARAMETER[5], PARAMETER[6], PARAMETER[7],
            PARAMETER[8], PARAMETER[9], list_test_result
        ])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result
    write_json_file(
        "../../ekt_json/dvbt2_69_performance_in_SFN_inside_guard.json",
        dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    # 将部分无需测试的点的json文件内容, 测试结果置为 NO NEED TEST
    dvbt2_69_performance_in_SFN_inside_guard_json_class_test(
        "../../ekt_json/dvbt2_69_performance_in_SFN_inside_guard.json")

Beispiel #17

else:
    dict_test_parame_result = {}
    list_test_parame_result = []

    dict_data = read_ekt_config_data("../../ekt_lib/ekt_config.json")
    DVBC_FREQUENCY_LEVEL_OFFSET = dict_data.get("DVBC_FREQUENCY_LEVEL_OFFSET")

    for PARAMETER in PARAMETER_LIST:
        list_test_result = []
        for FREQUENCY in FREQUENCY_LIST:
            list_test_result.append([FREQUENCY, None])
        list_test_parame_result.append(
            [PARAMETER[0], PARAMETER[1], PARAMETER[2], list_test_result])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result

    write_json_file("../../ekt_json/dvbc_3_cn_test.json",
                    dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置modulation,symbol_rate, CN, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file("../../ekt_json/dvbc_3_cn_test.json")
    sfu_ip = ekt_cfg.SFU_IP
    specan = Ektsfu(sfu_ip)
    specan.preset_instrument()

Beispiel #18

         [0, 243.1, 0, 0, 15, 486.1, None],
         [0, 243.1, 3, 0, 15, 486.1, None],
         [0, 243.1, 6, 0, 15, 486.1, None],
         [0, 243.1, 9, 0, 15, 486.1, None],
         [0, 243.1, 12, 0, 15, 486.1, None],
         [0, 243.1, 18, 0, 15, 486.1, None],
         [0, 243.1, 21, 0, 15, 486.1, None]]]
]

my_file = Path("../../ekt_json/dvbt2_68_performance_in_SFN_echo.json")
if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    dict_test_parame_result["test_parame_result"] = PARAMETER_LIST
    write_json_file("../../ekt_json/dvbt2_68_performance_in_SFN_echo.json",
                    dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file("../../ekt_json/dvbt2_68_performance_in_SFN_echo.json")
    sfu_ip = ekt_cfg.SFU_IP
    specan = Ektsfu(sfu_ip)
    specan.preset_instrument()

Beispiel #19

Datei: dvbt_19_performance_gaussian_channel.py Projekt: invictus86/front_end_code

        "DVBT_T2_FREQUENCY_LEVEL_OFFSET")

    for FREQUENCY_LEVEL_OFFSET in DVBT_T2_FREQUENCY_LEVEL_OFFSET:
        list_test_result = []
        for MODULATION_CODERATE_SPEC in MODULATION__CODERATE_SPEC_LIST:
            list_test_result.append([
                MODULATION_CODERATE_SPEC[0], MODULATION_CODERATE_SPEC[1],
                MODULATION_CODERATE_SPEC[2], MODULATION_CODERATE_SPEC[3], None,
                None
            ])

        list_test_parame_result.append(
            [FREQUENCY_LEVEL_OFFSET, list_test_result])

    dict_test_parame_result["test_parame_result"] = list_test_parame_result
    write_json_file("../../ekt_json/dvbt_19_performance_gaussian_channel.json",
                    dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    # 将部分无需测试的点的json文件内容, 测试结果置为 NO NEED TEST
    dvbt_19_gaussian_channel_json_class_test(
        "../../ekt_json/dvbt_19_performance_gaussian_channel.json")

Beispiel #20

Datei: dvbs2_25_signal_acquisition_frequency_range.py Projekt: invictus86/front_end_code

    dict_data = read_ekt_config_data("../../ekt_lib/ekt_config.json")
    DVBS2_8PSK_CODE_RATE_CN = dict_data.get("DVBS2_8PSK_CODE_RATE_CN")

    for SYMBOL_RATE_FREQUENCY in dict_config_data.get("SYMBOL_RATE_FREQUENCY"):
        for FREQUENCY_OFFSET in SYMBOL_RATE_FREQUENCY[2]:
            list_test_result = []
            for code_rate_cn in DVBS2_8PSK_CODE_RATE_CN:
                list_test_result.append([code_rate_cn, None])
            list_test_parame_result.append([
                SYMBOL_RATE_FREQUENCY[0], SYMBOL_RATE_FREQUENCY[1],
                FREQUENCY_OFFSET, list_test_result
            ])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result

    write_json_file(
        "../../ekt_json/dvbs2_25_signal_acquisition_frequency_range.json",
        dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置modulation,symbol_rate,code_rate,frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file(
        "../../ekt_json/dvbs2_25_signal_acquisition_frequency_range.json")
    sfu_ip = ekt_cfg.SFU_IP

Beispiel #21

Datei: dvbt2_53_changes_modulation_supplement_2_PARP.py Projekt: invictus86/front_end_code

if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    list_test_parame_result = []

    for PARAMETER in PARAMETER_LIST:
        list_test_parame_result.append([
            PARAMETER[0], PARAMETER[1], PARAMETER[2], PARAMETER[3],
            PARAMETER[4], PARAMETER[5], PARAMETER[6], PARAMETER[7]
        ])

    dict_test_parame_result["test_parame_result"] = list_test_parame_result

    write_json_file(
        "../../ekt_json/dvbt2_53_changes_modulation_supplement_2_PARP.json",
        dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file(
        "../../ekt_json/dvbt2_53_changes_modulation_supplement_2_PARP.json")
    sfu_ip = ekt_cfg.SFU_IP

Beispiel #22

my_file = Path("../../ekt_json/j83_5_IQ_inverted.json")
if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    list_test_parame_result = []

    for PARAMETER in PARAMETER_LIST:
        list_test_result = []
        for FREQUENCY in FREQUENCY_LIST:
            list_test_result.append([FREQUENCY, None])
        list_test_parame_result.append(
            [PARAMETER[0], PARAMETER[1], PARAMETER[2], PARAMETER[3], list_test_result])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result

    write_json_file("../../ekt_json/j83_5_IQ_inverted.json", dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置modulation,symbol_rate, CN, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file("../../ekt_json/j83_5_IQ_inverted.json")
    sfu_ip = ekt_cfg.SFU_IP
    specan = Ektsfu(sfu_ip)
    specan.preset_instrument()

Beispiel #23

Datei: dvbt2_53_changes_modulation_parameters.py Projekt: invictus86/front_end_code

if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    list_test_parame_result = []

    for PARAMETER in PARAMETER_LIST:
        list_test_parame_result.append([
            PARAMETER[0], PARAMETER[1], PARAMETER[2], PARAMETER[3],
            PARAMETER[4], PARAMETER[5], PARAMETER[6], PARAMETER[7]
        ])

    dict_test_parame_result["test_parame_result"] = list_test_parame_result

    write_json_file(
        "../../ekt_json/dvbt2_53_changes_modulation_parameters.json",
        dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file(
        "../../ekt_json/dvbt2_53_changes_modulation_parameters.json")
    sfu_ip = ekt_cfg.SFU_IP

Beispiel #24

if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    list_test_parame_result = []

    for SYMBOL_RATE in SYMBOL_RATE_LIST:
        for REQUENCY in REQUENCY_LIST:
            list_test_result = []
            for MODULATION in MODULATION_LIST:
                list_test_result.append([MODULATION, None])
            list_test_parame_result.append(
                [SYMBOL_RATE, REQUENCY, list_test_result])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result

    write_json_file("../../ekt_json/dvbc_9_frequency_error_rate.json",
                    dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置modulation,symbol_rate, CN, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file(
        "../../ekt_json/dvbc_9_frequency_error_rate.json")
    sfu_ip = ekt_cfg.SFU_IP
    specan = Ektsfu(sfu_ip)

Beispiel #25

    [
        FFT_SIZE_8K, MODULATION_64QAM, CODE_RATE_3_4, GUARD_G1_4, 27.6, 20, 10,
        None
    ],
]

# 无法设置fading 里面的Doppler     SFU的 set_fading_settings_reference 设置无效

my_file = Path("../../ekt_json/dvbt_29_performance_time_varying_channel.json")
if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    dict_test_parame_result["test_parame_result"] = PARAMETER_LIST
    write_json_file(
        "../../ekt_json/dvbt_29_performance_time_varying_channel.json",
        dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file(
        "../../ekt_json/dvbt_29_performance_time_varying_channel.json")
    sfu_ip = ekt_cfg.SFU_IP

Beispiel #26

Datei: dvbt_22_minimun_signal_level_0db.py Projekt: invictus86/front_end_code

    dict_test_parame_result = {}
    list_test_parame_result = []

    for PARAMETER_FIXED in PARAMETER_LIST:
        list_test_parame = []
        for PARAMETER in PARAMETER_FIXED[4]:
            list_test_result = []
            for fading in PARAMETER[5]:
                list_test_result.append([fading, None])
            list_test_parame.append(
                [PARAMETER[0], PARAMETER[1], PARAMETER[2], PARAMETER[3], PARAMETER[4], list_test_result])
        list_test_parame_result.append(
            [PARAMETER_FIXED[0], PARAMETER_FIXED[1], PARAMETER_FIXED[2], PARAMETER_FIXED[3], list_test_parame])

    dict_test_parame_result["test_parame_result"] = list_test_parame_result
    write_json_file("../../ekt_json/dvbt_22_minimun_signal_level_0db.json",
                    dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file("../../ekt_json/dvbt_22_minimun_signal_level_0db.json")
    sfu_ip = ekt_cfg.SFU_IP
    specan = Ektsfu(sfu_ip)
    specan.preset_instrument()

Beispiel #27

if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    list_test_parame_result = []

    for MODULATION in dict_config_data.get("MODULATION"):
        for CODE_RATE in dict_config_data.get("CODE_RATE"):
            for FFTSIZE_PIL_LEVEL_GUARD in FFTSIZE_PIL_LEVEL_GUARD_LIST:
                list_test_parame_result.append([
                    MODULATION, CODE_RATE, FFTSIZE_PIL_LEVEL_GUARD[0],
                    FFTSIZE_PIL_LEVEL_GUARD[1], FFTSIZE_PIL_LEVEL_GUARD[2],
                    FFTSIZE_PIL_LEVEL_GUARD[3], None
                ])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result
    write_json_file("../../ekt_json/dvbt2_37_modes.json",
                    dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file("../../ekt_json/dvbt2_37_modes.json")
    sfu_ip = ekt_cfg.SFU_IP
    specan = Ektsfu(sfu_ip)
    specan.preset_instrument()

Beispiel #28

Datei: dvbt_31_performance_SFN_more_than_one.py Projekt: invictus86/front_end_code

    list_test_parame_result = []

    for PARAMETER in PARAMETER_LIST:
        list_test_result = []
        for FADING in PARAMETER[5]:
            list_test_result.append([
                FADING[0], FADING[1], FADING[2], FADING[3], FADING[4],
                FADING[5], FADING[6]
            ])
        list_test_parame_result.append([
            PARAMETER[0], PARAMETER[1], PARAMETER[2], PARAMETER[3],
            PARAMETER[4], list_test_result
        ])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result
    write_json_file(
        "../../ekt_json/dvbt_31_performance_SFN_more_than_one.json",
        dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file(
        "../../ekt_json/dvbt_31_performance_SFN_more_than_one.json")
    sfu_ip = ekt_cfg.SFU_IP

Beispiel #29

    dict_test_parame_result = {}
    list_test_parame_result = []

    dict_data = read_ekt_config_data("../../ekt_lib/ekt_config.json")
    ANNEXB_FREQUENCY_LEVEL_OFFSET = dict_data.get(
        "ANNEXB_FREQUENCY_LEVEL_OFFSET")

    for PARAMETER in PARAMETER_LIST:
        list_test_result = []
        for FREQUENCY_LEVEL_OFFSET in ANNEXB_FREQUENCY_LEVEL_OFFSET:
            list_test_result.append([FREQUENCY_LEVEL_OFFSET, None])
        list_test_parame_result.append(
            [PARAMETER[0], PARAMETER[1], PARAMETER[2], list_test_result])
    dict_test_parame_result["test_parame_result"] = list_test_parame_result

    write_json_file("../../ekt_json/j83_1_dynamic_range_awng_min_level.json",
                    dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置modulation,symbol_rate, CN, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file(
        "../../ekt_json/j83_1_dynamic_range_awng_min_level.json")
    sfu_ip = ekt_cfg.SFU_IP
    specan = Ektsfu(sfu_ip)

Beispiel #30

LEVEL_30_666 = str("%.2f" % (-30 - LEVEL_OFFSET_666))

PARAMETER_LIST = [
    [FFT_SIZE_8K, MODULATION_64QAM, CODE_RATE_2_3, GUARD_G1_8, -35, None],
    [FFT_SIZE_8K, MODULATION_64QAM, CODE_RATE_2_3, GUARD_G1_4, -35, None],
    [FFT_SIZE_8K, MODULATION_64QAM, CODE_RATE_3_4, GUARD_G1_4, -35, None],
]

my_file = Path("../../ekt_json/dvbt_24_receiver_signal_maximum_level.json")
if my_file.exists():
    pass
else:
    dict_test_parame_result = {}
    dict_test_parame_result["test_parame_result"] = PARAMETER_LIST
    write_json_file(
        "../../ekt_json/dvbt_24_receiver_signal_maximum_level.json",
        dict_test_parame_result)

if __name__ == '__main__':
    """
    测试流程:
    ①重置设备
    ②选择 TSPLAYER
    ③播放流文件
    ④设置code_rate,modulation,bandwidth,guard, frequency,input_signal_level
    ⑤机顶盒应用中进行锁台并确认锁台成功  （针对stb-tester发送post请求运行testcase）
    ⑤依次修改可变参数,判断机顶盒画面是否含有马赛克并记录结果
    """
    load_dict = read_json_file(
        "../../ekt_json/dvbt_24_receiver_signal_maximum_level.json")
    sfu_ip = ekt_cfg.SFU_IP