Open a project, record something, wait for trace
Python
import sys
sys.path.append(“C:\Users\Public\Documents\LeCroy\Net Protocol Suite\API\SDK\Bin”)
import TLNetAPI
# OnTraceCreated callback for StartRecording
def OnTraceCreated(chain_index, file_name):
# ====
# Do your own callback logic here…
# ====
project = TLNetAPI.OpenProject(“myproject.gep”)
# Assign board with serial number 9 and connection USB to the project
project.Assign(9, TLNetAPI.EconnectionType.CONNECTION_TYPE_USB, 0, 0)
# Start chain 0, first/default trigger settings in project,
# OnTraceCreated callback, and no timeout
project.StartRecording(0,0,””, OnTraceCreated, None,None,0)
# ====
# Do your own program logic here…
# ====
# Stop chain 0 and start the trace upload
project.StopRecording(0, False)
# Wait until trace uploading is done. Note that this method requires
# Net 1.75 or later.
project.WaitForTraces(0)
del project
Open a trace file and retrieve packet count
Python
import sys
sys.path.append(“C:\Users\Public\Documents\LeCroy\Net Protocol Suite\API\SDK\Bin”)
import TLNetAPI
trace = TLNetAPI.OpenFile(“mytrace.get”)
trace.GetCount()
del trace
Retrieve protocol error from a packet
Python
pe_mask = packet.GetPEMask()
crc_mask = 1 << libTLNetAPI_python.EGEProtocolError.ID_PE_GE_FC_CRC_ERROR.value
has_crc_error = pe_mask & crc_mask
if(has_crc_error!=0):
print(‘has CRC Error’)
Auto negotiation Jamming
Python
# Frame Data
frame_data_event = APIFrameData()
# AN JAM Data
AN_jam = ActionANJam()
AN_jam.CodeWord = [‘1’, ‘0’, ‘1’, ‘0’, ‘1’, ‘0’, ‘1’, ‘0’, ‘1’, ‘0’, ‘1’, ‘0’]
AN_jam.ManchesterCode = [‘0’, ‘F’, ‘0’, ‘F’, ‘0’, ‘F’, ‘0’, ‘F’, ‘0’, ‘F’, ‘0’, ‘F’]
AN_jam.PageDelimiter = True
AN_jam.PseudoRandom = True
# Adding Event
(result, item_id) = jammer_manager.AddEvent(scenario_id, seq_0, 0, 0,
PatternType.ID_PATTERN_TYPE_GE_AUTO_NEGOTIATION_IEEE_802, event_general_setting,
frame_data_event)
# Adding Action
(result, action_id_1) = jammer_manager.AddAction(scenario_id, seq_0, 0, 0,
EICActionType.IC_ACTION_AUTO_NEGOTIATION, action_general_setting, AN_jam)
Jammer : Inserting Captured Dword Data in Frame Event
Python
# Frame Data Definition
frame_data1 = APIFrameData()
frame_data1.DataValues = [0xD, 0xE, 0xA, 0xD, 0xC, 0xC, 0xC,0xC]
frame_data1.DataIndexes = [20, 21, 22, 23, 24, 25, 26, 27]
frame_data1.DataMasks = [0, 0, 0, 0, 0, 0, 0, 0]
dwordInsert_data = APIDWORDCaptureData()
dwordInsert_data.CaptureIndex = EdwordCaptureRegisterIndex.DwordRegister_3
dwordInsert_data.StartByte = 0x2C
dwordInsert_data.Mask = [‘F’,’0’,’F’,’F’]
frame_data1.DwordCaptureDataList.append(dwordInsert_data)
Jammer: DWord Matcher Event / Replace DWord Action
Python
# Event Data
dword_match_event = APIFCDWordMatcher()
dword_match_event.Mode = EFCDWordMatcherMode.CustomDword_0
dword_match_event.Value = ['4', 'B', '0', '0', '0', '0', '0', '0']
dword_match_event.Mask = ['F', 'F', '0', '0', '0', '0', '0', '0']
print("Add Match Event")
# Adding the Event
(result, item_id) = jammer_manager.AddEvent(scenario_id, seq_global, 0, 0,PatternType.ID_PATTERN_TYPE_FC_DWORD_MATCHER,
event_general_setting, dword_match_event)
print("Action General Setting")
action_general_setting = APIActionGeneralSetting()
action_general_setting.MonitorCount = True
print("Action Data")
# Action Data
dword_replace_action = APIFCDWordMatcher()
dword_replace_action.Value = ['B', 'E', 'E', 'F', '0', '0', '0', '0']
dword_replace_action.Mask = ['F', 'F', 'F', 'F', '0', '0', '0', '0']
# Adding Action
(result, action_id_1) = jammer_manager.AddAction(scenario_id, seq_global, 0, 0,EICActionType.IC_ACTION_REPLACE_DWORD_GENERAL,
action_general_setting, dword_replace_action)
Jammer: Inject error action
Python
event_general_setting = APIEventGeneralSetting()
event_general_setting.CounterValue = 1
event_general_setting.CountRandomly = False
#event_general_setting.Direction = True
print("Symbol")
Symbol_ev = ['4', 'B', '0', '0', '0', '0', '0', '1', '0', '0', '0', '0', '0', '0', '0', '0']
SyncHeader_ev = ['1', '0']
Symbol_ac = ['4', 'B', '0', '0', '0', '0', '0', '1', '0', '0', '0', '0', '0', '0', '1', '0']
SyncHeader_ac = ['1', '0']
# Event Data
symbol_data_event = APISymbolData()
symbol_data_event.Symbol = Symbol_ev
symbol_data_event.SyncHeader = SyncHeader_ev
print("Add Symbol Event")
# Adding the Event
(result, item_id) = jammer_manager.AddEvent(scenario_id, seq_global, 0, 0,PatternType.ID_PATTERN_TYPE_GE_SYMBOL_66_BITS,
event_general_setting, symbol_data_event)
print("Action General Setting")
action_general_setting = APIActionGeneralSetting()
action_general_setting.MonitorCount = True
action_general_setting.NthOccuranceToStopScenario = 1 #0 to disable
print("Action Symbol")
# Action Data
symbol_data_action = APISymbolData()
symbol_data_action.Symbol = Symbol_ac
symbol_data_action.SyncHeader = SyncHeader_ac
# Adding Action
(result, action_id_1) = jammer_manager.AddAction(scenario_id, seq_global, 0, 0,EICActionType.IC_ACTION_GE25_SUBS_SYMBOL_16G_JAM,
action_general_setting, symbol_data_action)
inject_error_symbol = APIActionInjectErrorSymbol()
print("Inject Error IC_ACTION_GE25_INJECT_ERROR_TYPE_SYNC_HEADER")
inject_error_symbol.EnableFrameDetect = False
(result, action_id_1) = jammer_manager.AddAction(scenario_id, seq_global, 0, 0,
EICActionType.IC_ACTION_GE25_INJECT_ERROR_TYPE_SYNC_HEADER,
action_general_setting, inject_error_symbol)
print("Inject Error IC_ACTION_GE25_INJECT_ERROR_TYPE_BLOCK")
(result, action_id_1) = jammer_manager.AddAction(scenario_id, seq_global, 0, 0,
EICActionType.IC_ACTION_GE25_INJECT_ERROR_TYPE_BLOCK,
action_general_setting, inject_error_symbol)
print("Inject Error IC_ACTION_INJECT_ERROR_TYPE_BASERFEC_PARITY")
inject_error_fec = APIActionInjectErrorSymbol()
inject_error_fec.InjectErrorID = 1
(result, action_id_1) = jammer_manager.AddAction(scenario_id, seq_global, 0, 0,
EICActionType.IC_ACTION_INJECT_ERROR_TYPE_BASERFEC_PARITY,
action_general_setting, inject_error_fec)
print("Inject Error IC_ACTION_INJECT_ERROR_TYPE_RSFEC_PARITY")
inject_error_fec.InjectErrorID = 8
(result, action_id_1) = jammer_manager.AddAction(scenario_id, seq_global, 0, 0,
EICActionType.IC_ACTION_INJECT_ERROR_TYPE_RSFEC_PARITY,
action_general_setting, inject_error_fec)
print("Inject Error IC_ACTION_GE_INJECT_ERROR_TYPE_ALIGNMENT")
inject_error_alignment = APIActionInjectErrorAlignment()
inject_error_alignment.Position = 20
(result, action_id_1) = jammer_manager.AddAction(scenario_id, seq_global, 0, 0,
EICActionType.IC_ACTION_GE_INJECT_ERROR_TYPE_ALIGNMENT,
action_general_setting, inject_error_alignment)
print("Inject Error IC_ACTION_GE_INJECT_ERROR_TYPE_ALIGNMENT_BIP")
inject_error_alignment.Position = 2
(result, action_id_1) = jammer_manager.AddAction(scenario_id, seq_global, 0, 0,
EICActionType.IC_ACTION_GE_INJECT_ERROR_TYPE_ALIGNMENT_BIP,
action_general_setting, inject_error_alignment)
frame_data = APIFrameData()
frame_data.DataIndexes=[116,117,118,119]
frame_data.DataValues=[0x12,0x34,0x56,0x78]
frame_data.DataMasks=[0,0,0,0]
frame_event=APIFrameData()
event_general_setting.CounterValue = 1
print("Frame Event")
(result,item_id) = jammer_manager.AddEvent(scenario_id, EJammerSequencer.JAMMER_SEQUENCER_0, 0, 0, PatternType.ID_PATTERN_ROCE_NVME_FCTYPE_CONNECT_COMMAND, event_general_setting, frame_event)
(result,item_id) = jammer_manager.AddEvent(scenario_id, EJammerSequencer.JAMMER_SEQUENCER_0, 0, 1, PatternType.ID_PATTERN_ROCE_NVME_FCTYPE_CONNECT_COMMAND, event_general_setting, frame_event)
action_frame_general_setting=APIActionGeneralSetting()
ReplacementFrame=ActionFrameJam()
ReplacementFrame.FrameData=frame_data
ReplacementFrame.AutoCalculateCRC = True
#ReplacementFrame.AutoCalculateFCS = True
#ReplacementFrame.ReplaceCRC =['B', 'C', '5', 'F', '0', '1', '2', '3']
action_frame_general_setting.Direction=True
print("Frame Jam Action")
(result,action_id_1) = jammer_manager.AddAction(scenario_id, EJammerSequencer.JAMMER_SEQUENCER_0, 0, 0, EICActionType.IC_ACTION_GE_FRAME_MODIFY_JAM, action_frame_general_setting, ReplacementFrame)
action_frame_general_setting.Direction=True#for P2/P4/P6/P8 default is False for P1/P3/P5/P7
(result,action_id_1) = jammer_manager.AddAction(scenario_id, EJammerSequencer.JAMMER_SEQUENCER_0, 0, 1, EICActionType.IC_ACTION_GE25_INSERT_FRAME, action_frame_general_setting, ReplacementFrame)
action_frame_general_setting.Direction=False
(result) = jammer_manager.SetJamDirection(scenario_id,False)
print("Frame Based Error Injection")
event_general_setting.Direction = True
(result,item_id) = jammer_manager.AddEvent(scenario_id, EJammerSequencer.JAMMER_SEQUENCER_1, 0, 0, PatternType.ID_PATTERN_ROCE_NVME_FCTYPE_CONNECT_COMMAND, event_general_setting, frame_event)
event_general_setting.Direction = False
(result,item_id) = jammer_manager.AddEvent(scenario_id, EJammerSequencer.JAMMER_SEQUENCER_1, 0, 1, PatternType.ID_PATTERN_ROCE_NVME_FCTYPE_CONNECT_COMMAND, event_general_setting, frame_event)
print("Inject Error IC_ACTION_GE25_INJECT_ERROR_TYPE_SYNC_HEADER")
action_frame_general_setting.Direction=True
inject_error_symbol.EnableFrameDetect = True
inject_error_symbol.Offset = 10
inject_error_symbol.NumberofCorruptedSymbols = 8
inject_error_symbol.CorruptRemainingData = True
inject_error_symbol.CorruptSOF = True
inject_error_symbol.CorruptEOF = True
(result, action_id_1) = jammer_manager.AddAction(scenario_id, EJammerSequencer.JAMMER_SEQUENCER_1, 0, 0,
EICActionType.IC_ACTION_GE25_INJECT_ERROR_TYPE_SYNC_HEADER,action_frame_general_setting, inject_error_symbol)
action_frame_general_setting.Direction=False
inject_error_symbol.EnableFrameDetect = True
print("Inject Error IC_ACTION_GE25_INJECT_ERROR_TYPE_BLOCK")
(result, action_id_1) = jammer_manager.AddAction(scenario_id, EJammerSequencer.JAMMER_SEQUENCER_1, 0, 1, EICActionType.IC_ACTION_GE25_INJECT_ERROR_TYPE_BLOCK, action_frame_general_setting, inject_error_symbol)
Exerciser: Start Exerciser
Python
import sys
import os
import time
script_dir = os.path.dirname(os.path.realpath(__file__))
if(sys.platform == 'win32'):
sys.path.append(r'C:/Users/Public/Documents/LeCroy/Net Protocol Suite/API/SDK/Bin')
else:
sys.path.append(r'/usr/local/LeCroy/NetProtocolSuite/API/SDK/Bin')
import libTLNetAPI_python
def on_exerciser_exit_code(chain_index, device_index,pair_port_index,exit_code):
print("exerciser_exit_code : Chain Index:{} , device_index:{},exit_code:{}".format(chain_index, device_index,exit_code))
def report_exerciser_status(chain_index, device_index,pair_port_index,status):
print("exerciser_status : Chain Index:{} , device_index:{},status:{}".format(chain_index, device_index,status))
def report_exerciser_error(chain_index, device_index,pair_port_index,error):
print("exerciser_error : Chain Index:{} , device_index:{},error:{}".format(chain_index, device_index,error))
api_version = libTLNetAPI_python.GetVersion()
print('API version: ' + str(api_version))
fileName = script_dir + "/Exerciser-script.gep"
project = libTLNetAPI_python.OpenProject(fileName)
print("File Name : " + fileName)
project.Assign(20313, libTLNetAPI_python.EConnectionType.CONNECTION_TYPE_TCP, 0, 0)
project.StartExerciser(0, 0, 2 , "scriptname", on_exerciser_exit_code, report_exerciser_status, report_exerciser_error)
#time.sleep(2)
project.WaitForStatus(10)
del project
input("press any key to continue")
Auto Calibration: Start Auto calibration and stop when candidate is found
Python
import sys, time
import platform
import os
script_dir = os.path.dirname(os.path.realpath(__file__))
if platform.system() == 'Windows':
sys.path.append(r'C:/Users/Public/Documents/LeCroy/Net Protocol Suite/API/SDK/Bin')
import TLNetAPI
else:
sys.path.append(r'/usr/local/LeCroy/NetProtocolSuite/API/SDK/Bin')
import libTLNetAPI_python as TLNetAPI
import libTLNetAPI_python
from libTLNetAPI_python import *
def GetAutoCalibrationResultString(result):
return{
0 : "No Candidate Found",
1 : "Candidate Found",
2 : "Target Found",
3 : "Applying",
4 : "Completed",
}[result]
# AutoCalibration callback
def OnReportAutoCalibrationResult(chain_index,device_index,link_index, result, message):
print("Info : "+ message + " Result : " + GetAutoCalibrationResultString(result))
return
deviceManager = TLNetAPI.GetDeviceManager()
serial = 20969
dev_Stat = deviceManager.GetDeviceStatusBySerialNumber(serial)
print("Board serial Number:{} is {}".format(serial,dev_Stat))
project = TLNetAPI.CreateProject()
project.AddDeviceBySerialNumber(serial,
TLNetAPI.ELinkConfiguration.LINK_CONFIG__QSFP__A_100GPAM4__0, 0)
setting = TLNetAPI.APIAutoCalibrationSetting()
setting.LogEnabled = True
setting.ForceFullSweep = True
#setting.TargetValue = 0.0000000005
ACFilterParameter = TLNetAPI.APIAutoCalibrationFilterParameter()
ACFilterParameter.ParameterIDs = [TLNetAPI.EApiAutoCalibrationParameterID.AC_CTLE_BOOST_DUT_ID,
TLNetAPI.EApiAutoCalibrationParameterID.AC_AMP_GAIN_DUT_ID,
TLNetAPI.EApiAutoCalibrationParameterID.AC_CTLE_BOOST_ANA_ID,
TLNetAPI.EApiAutoCalibrationParameterID.AC_AMP_GAIN_ANA_ID]
ACFilterParameter.ValuesLowerLimit = [1,1,1,2]
ACFilterParameter.ValuesUpperLimit = [5,4,5,5]
setting.FilterParameter = ACFilterParameter
project.StartAutoCalibration(0, 0, 0,setting, OnReportAutoCalibrationResult)
print("Auto Calibration has started")
time.sleep(600)
print("Force Stopping Auto Calibration")
project.StopAutoCalibration(0, 0, 0)
del project
Jammer: In Frame sub frame jam actions
Python
print("Action Frame Jam")
action_modify_frame_data = ActionFrameJam()
#Invert sub action
invert_action = APIReplaceInvertAction()
invert_action.StartByte = 0x05
invert_action.Mask = ['5','6']
action_modify_frame_data.ReplaceInvertAction.append(invert_action)
invert_action = APIReplaceInvertAction()
invert_action.StartByte = 0x10
invert_action.Mask = ['0','F']
action_modify_frame_data.ReplaceInvertAction.append(invert_action)
#Inject Error sub action
error_action = APIReplaceWithErrorAction()
error_action.StartByte = 0x15
error_action.ErrorType = EApiReplaceInjectErrorAction.REPLACE_WITH_ERROR_CODE_VIOLATION
action_modify_frame_data.ReplaceWithErrorAction.append(error_action)
error_action = APIReplaceWithErrorAction()
error_action.StartByte = 0x25
error_action.ErrorType = EApiReplaceInjectErrorAction.REPLACE_WITH_ERROR_DISPARITY
action_modify_frame_data.ReplaceWithErrorAction.append(error_action)
#Replace with orderset sub action
orderset_action = APIReplaceWithOrdersetAction()
orderset_action.StartByte = 0x30
orderset_action.UserData = ['B', 'C', '9', '5', '7', '5', '7', '5']
action_modify_frame_data.ReplaceWithOrdersetAction.append(orderset_action)
orderset_action = APIReplaceWithOrdersetAction()
orderset_action.StartByte = 0x40
orderset_action.UserData = ['X', 'C', '9', '5', '4', 'A', 'X', 'A']
action_modify_frame_data.ReplaceWithOrdersetAction.append(orderset_action)
#Replace Dword sub action
replace_dword_action = APIReplaceWithDWORDAction()
replace_dword_action.StartByte = 0x50
replace_dword_action.DwordType = EApiReplaceDWORDAction.REPLACE_WITH_CRC
action_modify_frame_data.ReplaceWithDWORDAction.append(replace_dword_action)
replace_dword_action = APIReplaceWithDWORDAction()
replace_dword_action.StartByte = 0x54
replace_dword_action.DwordType = EApiReplaceDWORDAction.REPLACE_WITH_IDLE
action_modify_frame_data.ReplaceWithDWORDAction.append(replace_dword_action)
replace_dword_action = APIReplaceWithDWORDAction()
replace_dword_action.StartByte = 0x58
replace_dword_action.DwordType = EApiReplaceDWORDAction.REPLACE_WITH_IDLE
action_modify_frame_data.ReplaceWithDWORDAction.append(replace_dword_action)
(result, action_id_1) = jammer_manager.AddAction(scenario_id, seq_global, 0, 0,
EICActionType.IC_ACTION_FC_FRAME_MODIFY_JAM, action_general_setting, action_modify_frame_data)
Get Pre-FEC BER read from FEC counter M1288
Python
import sys, time
import platform
import os
script_dir = os.path.dirname(os.path.realpath(__file__))
if platform.system() == 'Windows':
sys.path.append(r'C:/Users/Public/Documents/LeCroy/Net Protocol Suite/API/SDK/Bin')
import TLNetAPI
else:
sys.path.append(r'/usr/local/LeCroy/NetProtocolSuite/API/SDK/Bin')
import libTLNetAPI_python as TLNetAPI
import libTLNetAPI_python
from libTLNetAPI_python import *
deviceManager = TLNetAPI.GetDeviceManager()
serial = 24986#25734#24522#24986
dev_Stat = deviceManager.GetDeviceStatusBySerialNumber(serial)
print("Board serial Number:{} is {}".format(serial,dev_Stat))
project = TLNetAPI.CreateProject()
project.AddDeviceBySerialNumber(serial, TLNetAPI.ELinkConfiguration.LINK_CONFIG__QSFPDD__A_100GPAM4CR2__0__0__0, 0)
print("Board activated")
num_of_secs =10
while(num_of_secs):
time.sleep(1)
if num_of_secs%7 == 0:
print("Resetting Port Fec Counter")
project.ResetFecInfo(0,0,0)
project.ResetFecInfo(0,0,1)
print("Getting Fec Info")
ber_read_port3 = project.GetPortFecInfo(0,0,0,True)
ber_read_port4 = project.GetPortFecInfo(0,0,1,True)
print("Getting GetPortFecBer")
print("Ber value port3: is {}".format(ber_read_port3.GetPortFecBer()))
print("Ber value port4: is {}".format(ber_read_port4.GetPortFecBer()))
ber_lanes = [0,1]
for lane in ber_lanes:
print("Getting Ber value for lane{}:".format(lane))
print("Ber value port3lane{}: is {}".format(lane, ber_read_port3.GetLaneFecBer(lane)))
print("Ber value port4lane{}: is {}".format(lane, ber_read_port4.GetLaneFecBer(lane)))
num_of_secs -= 1
project.SaveAs(r"C:\\Api\\M1288_BERRead.gep")
del project
Write Device Probe Calibration for M1288
Python
deviceManager = TLNetAPI.GetDeviceManager()
serial = 24522 #replace with your board serial number
dev_Stat = deviceManager.GetDeviceStatusBySerialNumber(serial)
print("Board serial Number:{} is {}".format(serial,dev_Stat))
project = TLNetAPI.CreateProject()
project.AddDeviceBySerialNumber(serial, TLNetAPI.ELinkConfiguration.LINK_CONFIG__QSFPDD__A_400GPAM4__0__0__0, 0)
setting = TLNetAPI.APIDeviceProbeCalibrationSetting()
setting.ParameterIDs = [TLNetAPI.EApiAutoCalibrationParameterID.AC_DC_GAIN_ANA_ID,TLNetAPI.EApiAutoCalibrationParameterID.AC_EQ_GAIN_ANA_ID,
TLNetAPI.EApiAutoCalibrationParameterID.AC_DC_GAIN_DUT_ID, TLNetAPI.EApiAutoCalibrationParameterID.AC_EQ_GAIN_DUT_ID]
setting.Values = [1,2,1,6]
project.WriteDeviceProbeCalibrationSettings(0, 0, 0, 1, setting)#odd port lane 1
project.WriteDeviceProbeCalibrationSettings(0, 0, 1, 1, setting)
project.WriteDeviceProbeCalibrationSettings(0, 0, 0, 6, setting)
project.WriteDeviceProbeCalibrationSettings(0, 0, 1, 6, setting)#even port lane 6
del project