def Open(self, Handle=0):
'''
Opens a connexion with an AB3510 equipment.
This method is called by the constructor of AB3510 class if only 1 board is present
'''
from PyApex.Constantes import ABXXXX_ERROR_BAD_HANDLE
from PyApex.Errors import ApexError
from sys import exit
if self.Simulation:
print("Connected successfully to the equipment")
else:
try:
Devices = self.Find()
if len(Devices) == 0:
raise ApexError(ABXXXX_NO_EQUIPMENT_FOUND, "AB3510")
exit()
elif len(Devices) <= Handle:
raise ApexError(ABXXXX_ERROR_BAD_HANDLE, Handle)
exit()
self.Device = Devices[Handle]
self.Device.set_configuration()
print("Connected successfully to the equipment")
except:
print("Cannot connect to the equipment")
def GetNPoints(self, TraceNumber=1):
'''
Get the number of points for the specified trace on the OSA Fast-Sweep
TraceNumber is an integer between 1 (default) and 6
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Errors import ApexError
from random import randint
if not isinstance(TraceNumber, (int)):
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "TraceNumber")
sys.exit()
if TraceNumber < 0 or TraceNumber > 6:
raise ApexError(APXXXX_ERROR_ARGUMENT_VALUE, "TraceNumber")
sys.exit()
if self.__Simulation:
NPoints = randint(400, 600)
else:
Command = "OSAFSPOINTS" + str(int(TraceNumber)) + "\n"
Send(self.__Connexion, Command)
try:
NPoints = int(Receive(self.__Connexion)[:-1])
except:
NPoints = 0
return NPoints
def SetScaleYUnit(self, ScaleYUnit=0):
'''
Defines the unit of the Y-Axis
ScaleXUnit can be a string or an integer
If ScaleYUnit is :
- "lin" or 0, Y-Axis unit is in mW (default)
- "log" or 1, Y-Axis unit is in dBm or dBm
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Errors import ApexError
if isinstance(ScaleYUnit, str):
if ScaleYUnit.lower() == "log":
ScaleYUnit = 1
else:
ScaleYUnit = 0
if not isinstance(ScaleYUnit, int):
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "ScaleYUnit")
sys.exit()
if not ScaleYUnit in self.__ValidScaleUnits:
raise ApexError(APXXXX_ERROR_ARGUMENT_VALUE, "ScaleYUnit")
sys.exit()
if not self.__Simulation:
Command = "SPLINSC" + str(ScaleYUnit) + "\n"
Send(self.__Connexion, Command)
self.__ScaleYUnit = ScaleYUnit
def LockTrace(self, TraceNumber, Lock):
'''
Lock or unlock a trace
TraceNumber is an integer between 1 and 6
Lock is a boolean:
- True: the trace TraceNumber is locked
- False: the trace TraceNumber is unlocked
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE, APXXXX_ERROR_BAD_FILENAME
from PyApex.Errors import ApexError
if not isinstance(TraceNumber, int):
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "TraceNumber")
sys.exit()
if not TraceNumber in self.__Validtracenumbers:
raise ApexError(APXXXX_ERROR_ARGUMENT_VALUE, "TraceNumber")
sys.exit()
if Lock:
Lock = True
else:
Lock = False
if not self.__Simulation:
if Lock:
Command = "SPTRLOCK" + str(TraceNumber) + "\n"
else:
Command = "SPTRUNLOCK" + str(TraceNumber) + "\n"
Send(self.__Connexion, Command)
def GetEEPromData(self, BytesNumber):
'''
Get Data from the EEPROM of AB3510
BytesNumber is the number of bytes to read from the EEProm
Returns an array of the data bytes
'''
from PyApex.Constantes import AB3510_VR_GET_EEPROM_PARAMETERS, ABXXXX_EP0_READ_ERROR,\
APXXXX_ERROR_ARGUMENT_TYPE
from PyApex.Errors import ApexError
from sys import exit
if not isinstance(BytesNumber, int):
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "BytesNumber")
exit()
if self.Simulation:
return -1
else:
Data = self.Device.ctrl_transfer(0xC0,
AB3510_VR_GET_EEPROM_PARAMETERS,
BytesNumber, 0, BytesNumber)
try:
len(Data)
except:
raise ApexError(ABXXXX_EP0_READ_ERROR,
AB3510_VR_GET_EEPROM_PARAMETERS)
return -1
else:
return Data
def GetPower(self, Polar=0):
'''
Get the power measured by the Powermeter equipment
The return power is expressed in the unit defined by the GetUnit() method
Polar is the polarization channel :
- 0 : Total power (default)
- 1 : Power of polarization channel n°1
- 2 : Power of polarization channel n°2
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Constantes import APXXXX_ERROR_VARIABLE_NOT_DEFINED
from PyApex.Errors import ApexError
from random import random
if not isinstance(Polar, (int)):
self.__Connexion.close()
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "Polar")
if self.__Simulation:
if self.__Unit.lower() == "dbm":
Power = 60.0 * random() - 50.0
elif self.__Unit.lower() == "mw":
Power = 10.0 * random()
else:
self.__Connexion.close()
raise ApexError(APXXXX_ERROR_VARIABLE_NOT_DEFINED,
"self.__Unit")
else:
Command = "SPMEASDETECTORDBM1\n"
Send(self.__Connexion, Command)
Power = Receive(self.__Connexion)
return float(Power[:-1])
def LineWidth(self, TraceNumber=1, Get="width"):
'''
Gets the 3-db line width of the selected trace
TraceNumber is an integer between 1 (default) and 6
ThresholdValue is a float expressed in dB
Get is a string between the following values:
- Get = "WIDTH" : only the line width is returned (default)
- Get = "CENTER" : only the line width center is returned
- Get = "LEVEL" : only the line width peak level is returned
- Get = "ALL" : all line width values are returned in a list
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Errors import ApexError
if not isinstance(TraceNumber, int):
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "TraceNumber")
sys.exit()
if not TraceNumber in self.__Validtracenumbers:
raise ApexError(APXXXX_ERROR_ARGUMENT_VALUE, "TraceNumber")
sys.exit()
if not self.__Simulation:
Command = "SPLWTH" + str(TraceNumber) + "_3.0\n"
Send(self.__Connexion, Command)
Str = Receive(self.__Connexion, 64)[:-1]
Values = []
Str = Str.split("_")
for s in Str:
for v in s.split(" "):
if v.lower() not in ["dbm", "mw", "nm", "ghz"]:
try:
Values.append(float(v))
except:
pass
while len(Values) < 3:
Values.append(0.0)
else:
Values = [0.100, 1550.000, 2.25]
if str(Get).lower() == "all":
return Values
elif str(Get).lower() == "center":
return Values[1]
elif str(Get).lower() == "level":
return Values[2]
else:
return Values[0]
def GetMarkers(self, TraceNumber=1, Axis='y'):
'''
Gets the X-axis or Y-axis markers of a selected trace
TraceNumber is an integer between 1 (default) and 6
Axis is a string or an integer for selecting the axis:
Axis = 0 or 'X' : get the X-axis values of the markers
Axis = 1 or 'Y' : get the Y-axis values of the markers (default)
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Errors import ApexError
if not isinstance(Axis, (int, str)):
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "Axis")
sys.exit()
if not Axis in [0, 1] and not str(Axis).lower() in ['x', 'y']:
raise ApexError(APXXXX_ERROR_ARGUMENT_VALUE, "Axis")
sys.exit()
if not isinstance(TraceNumber, int):
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "TraceNumber")
sys.exit()
if not TraceNumber in self.__Validtracenumbers:
raise ApexError(APXXXX_ERROR_ARGUMENT_VALUE, "TraceNumber")
sys.exit()
if str(Axis).lower() == 'x':
Axis = 0
else:
Axis = 1
Markers = []
if not self.__Simulation:
if Axis:
Command = "SPDATAMKRY" + str(TraceNumber) + "\n"
else:
Command = "SPDATAMKRX" + str(TraceNumber) + "\n"
Send(self.__Connexion, Command)
Str = Receive(self.__Connexion, 64)[:-1]
Str = Str.split(" ")
Str = Str[1:]
for v in Str:
if v.lower() not in ["dbm", "mw", "nm", "ghz"]:
try:
Markers.append(float(v))
except:
pass
return Markers
def Send(Connexion, Command):
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_BADCOMMAND
from PyApex.Errors import ApexError
from sys import exit
from socket import timeout
if not isinstance(Command, str):
Connexion.close()
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "Command")
try:
Connexion.send(Command.encode('utf-8'))
except timeout:
Connexion.close()
raise ApexError(APXXXX_ERROR_BADCOMMAND, Command)
def AutoMeasure(self, TraceNumber=1, NbAverage=1):
'''
Auto measurement which performs a single and looks for the maximum peak
If a peak is detected, this method selects the spectral range and modify the span
TraceNumber is an integer between 1 (default) and 6
NbAverage is the number of average to perform after the span selection (no average by default)
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Constantes import AP2XXX_WLMIN, AP2XXX_WLMAX
from PyApex.Errors import ApexError
if not isinstance(TraceNumber, int):
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "TraceNumber")
sys.exit()
if not isinstance(NbAverage, (int, float)):
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "NbAverage")
sys.exit()
if int(NbAverage) < 1:
NbAverage = 1
if not TraceNumber in self.__Validtracenumbers:
raise ApexError(APXXXX_ERROR_ARGUMENT_VALUE, "TraceNumber")
sys.exit()
self.DeleteAll()
self.SetStartWavelength(AP2XXX_WLMIN)
self.SetStopWavelength(AP2XXX_WLMAX)
self.Run()
PeakValue = self.FindPeak(TraceNumber, ThresholdValue=20.0, Find="Max")
if PeakValue != 0.0:
if self.ScaleXUnit == 0:
self.SetSpan(125.0)
else:
self.SetSpan(1.0)
self.SetCenter(PeakValue)
self.DeleteAll()
self.DelAllMarkers(TraceNumber)
if int(NbAverage) > 1:
self.ActivateAverageMode()
for i in range(NbAverage):
self.Run()
if int(NbAverage) > 1:
self.DesactivateAverageMode()
def SetAverageTime(self, AvgTime):
'''
Set the average time of the PWM equipment
AvgTime is expressed in ms
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Constantes import AP1000_PWM_AVGMIN, AP1000_PWM_AVGMAX
from PyApex.Errors import ApexError
try:
AvgTime = float(AvgTime)
except:
self.__Connexion.close()
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "AvgTime")
else:
if AvgTime < AP1000_PWM_AVGMIN:
print("PyApex Warning. PWM Average time is set to its minimum value: " + \
str(AP1000_PWM_AVGMIN) + " ms !")
AvgTime = AP1000_PWM_AVGMIN
if AvgTime > AP1000_PWM_AVGMAX:
print("PyApex Warning. PWM Average time is set to its maximum value: " + \
str(AP1000_PWM_AVGMAX) + " ms !")
AvgTime = AP1000_PWM_AVGMAX
if not self.__Simulation:
Command = "POW[" + str(self.__SlotNumber).zfill(2) + "]:SETAVERAGE" + \
str(AvgTime) + "\n"
Send(self.__Connexion, Command)
self.__AvgTime = AvgTime
def GetWavelength(self, ChNumber=1):
'''
Get wavelength of the channel ChNumber of the PWM equipment
The return wavelength is expressed in nm
ChNumber is the channel number : 1 (default) or 2
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Errors import ApexError
try:
ChNumber = int(ChNumber)
except:
self.__Connexion.close()
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "ChNumber")
else:
if ChNumber > len(self.__Channels):
print("PyApex Warning. PWM Channel is set to 1 !")
ChNumber = 1
if not self.__Simulation:
Command = "POW[" + str(slef.__SlotNumber).zfill(2) + "]:WAV[" + \
str(ChNumber) + "]?\n"
Send(self.__Connexion, Command)
self.__Wavelength = float(Receive(self.__Connexion)[:-1])
return self.__Wavelength
def SetFrequency(self, Frequency):
'''
Set frequency of the DFB equipment
Frequency is expressed in GHz
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Constantes import VACCUM_LIGHT_SPEED, AP1000_DFB_FRMIN, AP1000_DFB_FRMAX
from PyApex.Errors import ApexError
try:
Frequency = float(Frequency)
except:
self.Off()
self.__Connexion.close()
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "Frequency")
else:
if Frequency < AP1000_DFB_FRMIN[self.__Type]:
print("PyApex Warning. DFB Frequency is set to its minimum value: " + \
str(AP1000_DFB_FRMIN[self.__Type]) + " nm !")
Frequency = AP1000_DFB_FRMIN[self.__Type]
if Frequency > AP1000_DFB_FRMAX[self.__Type]:
print("PyApex Warning. DFB Frequency is set to its maximum value: " + \
str(AP1000_DFB_FRMAX[self.__Type]) + " nm !")
Frequency = AP1000_DFB_FRMAX[self.__Type]
self.SetWavelength(VACCUM_LIGHT_SPEED / Frequency)
def SetOSAMode(self, Mode="Sensitive"):
'''
Set the OSA Fast-Sweep mode (Fast or High-Sensitivity)
Mode can be a string or an integer :
- Mode = 1 or "Fast" : OSA Fast-Sweep will run in fast mode
- Mode = 2 or "Sensitive" : OSA Fast-Sweep will run in high-sensitivity mode (default)
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE
from PyApex.Errors import ApexError
if isinstance(Mode, (str)):
if str(Mode).lower() == "fast":
Mode = 1
else:
Mode = 2
elif isinstance(Mode, (int, float)):
if Mode != 2:
Mode = 1
else:
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "Mode")
sys.exit()
if not self.__Simulation:
Command = "OSAFSMODE" + str(Mode) + "\n"
Send(self.__Connexion, Command)
self.__Mode = Mode
def SetIPump(self, IPump):
'''
Set laser pump current of the EFA equipment
IPump is expressed in mA
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Constantes import AP1000_EFA_IPMAX
from PyApex.Errors import ApexError
try:
IPump = float(IPump)
except:
self.__Connexion.close()
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "IPump")
else:
if IPump > AP1000_EFA_IPMAX[self.__Type]:
IPump = AP1000_EFA_IPMAX[self.__Type]
if IPump < 0:
IPump = 0
if not self.__Simulation:
Command = "AMP[" + str(self.__SlotNumber).zfill(2) + "]:PUMP" + \
("%.1f" % IPump) + "\n"
Send(self.__Connexion, Command)
self.__IPump = IPump
def GetOSAMode(self, Type='d'):
'''
Return the OSA Fast-Sweep mode (Fast or High-Sensitivity)
if Type = 'd' (default), return a digit :
- 1 for Fast
- 2 for Sensitive
if Type = 's', return a string :
- "Fast" for Fast
- "Sensitive" for High-Sensitivity
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE
from PyApex.Errors import ApexError
if not isintance(Type, (str)):
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "Type")
sys.exit()
if not self.__Simulation:
Command = "OSAFSMODE?\n"
Send(self.__Connexion, Command)
self.__Mode = int(Receive(self.__Connexion)[:-1])
if str(Type).lower() == 's':
if self.__Mode == 1:
return "Fast"
elif self.__Mode == 2:
return "Sensitive"
else:
return "Unknown Mode"
else:
return self.__Mode
def Run(self, Type="single"):
'''
Run a measurement with the OSA Fast-Sweep
If Type is
- "single" or 1, a single measurement is running (default)
- "repeat" or 2, a repeat measurement is running
'''
from PyApex.Errors import ApexError
if isinstance(Type, str):
if Type.lower() == "repeat":
Command = "OSAFSRUN2\n"
else:
Command = "OSAFSRUN1\n"
elif isinstance(Type, (int, float)):
if Type == 2:
Command = "OSAFSRUN2\n"
else:
Command = "OSAFSRUN1\n"
else:
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "Type")
sys.exit()
if not self.__Simulation:
Send(self.__Connexion, Command)
def GetPower(self):
'''
Get the total power of the POL equipment
The return power is expressed in the unit defined by the GetUnit() method
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Constantes import APXXXX_ERROR_VARIABLE_NOT_DEFINED
from PyApex.Errors import ApexError
from random import random
if self.__Simulation:
Power = random() * 70.0 - 60.0
if self.__Unit.lower() == "mw":
Power = 10.0**(Power / 10.0)
else:
if self.__Unit.lower() == "dbm":
Command = "POL[" + str(self.__SlotNumber).zfill(2) + "]:DBM?\n"
elif self.__Unit.lower() == "mw":
Command = "POL[" + str(self.__SlotNumber).zfill(2) + "]:MW?\n"
else:
self.__Connexion.close()
raise ApexError(APXXXX_ERROR_VARIABLE_NOT_DEFINED,
"self.__Unit")
Send(self.__Connexion, Command)
Power = Receive(self.__Connexion)
try:
Power = float(Power[:-1])
except:
Power = float("NAN")
return Power
def SetPolarimeterPath(self, Path="full"):
'''
Sets the polarimeter path
Path can be a string or an integer
- Path = "full" or 0 : the polarimeter input is used (no optical filter) (default)
- Path = "filtered" or 1 : the OSA input is used (a 170 pm optical filter is used)
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE
from PyApex.Errors import ApexError
if not self.__Simulation:
Command = "POLPATH"
if isinstance(Path, str):
if Path.lower() == "filtered":
Command += "1"
else:
Command += "0"
elif isinstance(Path, int):
if Path == 1:
Command += "1"
else:
Command += "0"
else:
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "Path")
sys.exit()
Command += "\n"
Send(self.__Connexion, Command)
def GetSample(self):
'''
Get one sample from the 4 channels of AB3510
'''
from PyApex.Constantes import AB3510_VR_GET_SAMPLE, ABXXXX_EP0_READ_ERROR
from PyApex.Errors import ApexError
from sys import exit
Samples = []
if self.Simulation:
for i in range(0, 4):
Samples.append(randint(0, 16383))
else:
try:
SampleWord = self.Device.ctrl_transfer(0xC0,
AB3510_VR_GET_SAMPLE, 0,
0, 8)
except:
raise ApexError(ABXXXX_EP0_READ_ERROR, AB3510_VR_GET_SAMPLE)
exit()
else:
for i in range(0, 8, 2):
Samples.append(
int((SampleWord[i] + (SampleWord[i + 1] * 256)) / 4))
return Samples
def GetAttenuation(self, ChNumber=1):
'''
Get attenuation of the ATT equipment
The return attenuation is expressed in the unit defined by the GetUnit() method
ChNumber is the channel number : 1 (default) or 2
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Constantes import AP1000_ATT_CHNUMBER, SimuATT_Attenuation
from PyApex.Errors import ApexError
try:
ChNumber = int(ChNumber)
except:
self.__Connexion.close()
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "ChNumber")
else:
if ChNumber > AP1000_ATT_CHNUMBER:
ChNumber = AP1000_ATT_CHNUMBER
if ChNumber < 1:
ChNumber = 1
if not self.__Simulation:
Command = "ATT[" + str(self.__SlotNumber).zfill(2) + "]:DB[" + \
str(ChNumber-1) + "]?\n"
Send(self.__Connexion, Command)
self.__Attenuation = self.__ConvertForReading(
float(Receive(self.__Connexion)[:-1]))
return self.__Attenuation
def GetType(self):
'''
Return the type of the TLS
return 0 for a C band Laser
return 2 for a L band Laser
'''
from PyApex.Constantes import AP1000_ERROR_SLOT_TYPE_NOT_DEFINED
from PyApex.Constantes import SimuTLS_SlotID, AP1000_TLS_CBAND, AP1000_TLS_LBAND
from PyApex.Errors import ApexError
import re
if self.__Simulation:
ID = SimuTLS_SlotID
else:
Command = "SLT[" + str(self.__SlotNumber).zfill(2) + "]:IDN?\n"
Send(self.__Connexion, Command)
ID = Receive(self.__Connexion)
if re.findall(str(AP1000_TLS_CBAND), ID.split("/")[1]) != []:
return 0
elif re.findall(str(AP1000_TLS_LBAND), ID.split("/")[1]) != []:
return 2
else:
self.Off()
self.__Connexion.close()
raise ApexError(AP1000_ERROR_SLOT_TYPE_NOT_DEFINED, self.__SlotNumber)
def __ConvertForWriting(self, Value, Type="power"):
'''
Internal use only
Type is the type of value to convert:
If Type is:
- "power" or 1, the function converts a power in dBm
- "gain" or 2, the function converts a gain in dB
Value is the value to convert
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_VALUE, APXXXX_ERROR_VARIABLE_NOT_DEFINED
from PyApex.Errors import ApexError
from math import log10 as log
Type = str(Type).lower()
if Type == "gain" or Type == 2:
Type = 2
else:
Type = 1
if (self.__Unit.lower() == "dbm"
and Type == 1) or (self.__GainUnit.lower() == "db"
and Type == 2):
return Value
else:
try:
log(Value)
except:
self.__Connexion.close()
raise ApexError(APXXXX_ERROR_ARGUMENT_VALUE, "Value")
else:
if Type == 2:
Value /= 100.0
return 10.0 * log(Value / 10.0)
def SetWavelength(self, Wavelength):
'''
Set wavelength of the TLS equipment
Wavelength is expressed in nm
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Constantes import AP1000_TLS_WLMIN, AP1000_TLS_WLMAX
from PyApex.Errors import ApexError
try:
Wavelength = float(Wavelength)
except:
self.Off()
self.__Connexion.close()
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "Wavelength")
else:
if Wavelength < AP1000_TLS_WLMIN[self.__Type]:
print("PyApex Warning. TLS Wavelength is set to its minimum value: " + \
str(AP1000_TLS_WLMIN[self.__Type]) + " nm !")
Wavelength = AP1000_TLS_WLMIN[self.__Type]
if Wavelength > AP1000_TLS_WLMAX[self.__Type]:
print("PyApex Warning. TLS Wavelength is set to its maximum value: " + \
str(AP1000_TLS_WLMAX[self.__Type]) + " nm !")
Wavelength = AP1000_TLS_WLMAX[self.__Type]
if not self.__Simulation:
Command = "TLS[" + str(self.__SlotNumber).zfill(2) + "]:TWL" + \
("%4.3f" % Wavelength).zfill(8) + "\n"
Send(self.__Connexion, Command)
self.__Wavelength = Wavelength
def SetPower(self, Power):
'''
Set output power of the TLS equipment
Power is expressed in the unit defined by the GetUnit() method
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Constantes import AP1000_TLS_POWMIN, AP1000_TLS_POWMAX
from PyApex.Errors import ApexError
try:
Power = float(Power)
except:
self.Off()
self.__Connexion.close()
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "Power")
else:
Power = self.__ConvertForWriting(Power)
if Power < AP1000_TLS_POWMIN[self.__Type]:
print("PyApex Warning. TLS Power is set to its minimum value: " + \
str(AP1000_TLS_POWMIN[self.__Type]) + " dBm !")
Power = AP1000_TLS_POWMIN[self.__Type]
elif Power > AP1000_TLS_POWMAX[self.__Type]:
print("PyApex Warning. TLS Power is set to its maximum value: " + \
str(AP1000_TLS_POWMIN[self.__Type]) + " dBm !")
Power = AP1000_TLS_POWMAX[self.__Type]
if not self.__Simulation:
Command = "TLS[" + str(self.__SlotNumber).zfill(2) + "]:TPDB" + \
("%.1f" % Power) + "\n"
Send(self.__Connexion, Command)
self.__Power = Power
def Receive(Connexion, ByteNumber=1024):
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_COMMUNICATION
from PyApex.Errors import ApexError
from sys import exit
from socket import timeout
if not isinstance(ByteNumber, int):
Connexion.close()
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "ByteNumber")
try:
data = Connexion.recv(ByteNumber)
except timeout:
Connexion.close()
raise ApexError(APXXXX_ERROR_COMMUNICATION, Connexion.getsockname()[0])
else:
return data.decode('utf-8')
def SetEEPromData(self, Data):
'''
Set Data into the EEPROM of AB3510
Data is a bytes object to write into the EEProm
'''
from PyApex.Constantes import AB3510_VR_SET_EEPROM_PARAMETERS, ABXXXX_EP0_WRITE_ERROR,\
APXXXX_ERROR_ARGUMENT_TYPE
from PyApex.Errors import ApexError
from sys import exit
if not isinstance(Data, (bytes, bytearray)):
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "Data")
exit()
if self.Simulation:
return True
else:
if len(Data) <= 64:
self.Device.ctrl_transfer(0x40,
AB3510_VR_SET_EEPROM_PARAMETERS,
len(Data), 0, Data)
else:
Length = len(Data)
print("Send the first 64 bytes")
self.Device.ctrl_transfer(0x40,
AB3510_VR_SET_EEPROM_PARAMETERS,
Length, 0, Data[0:64])
Index = 64
Length -= 64
for i in range(int(Length / 64)):
print("Send the " + str(i) + "ieme 64 bytes")
self.Device.ctrl_transfer(0x40, 0, 0, 0,
Data[Index:Index + 64])
Index += 64
Length -= 64
if Length > 0:
print("Send the last " + str(Length) + " bytes")
self.Device.ctrl_transfer(0x40, 0, 0, 0,
Data[Index:Index + Length + 1])
try:
len(Data)
except:
raise ApexError(ABXXXX_EP0_WRITE_ERROR,
AB3510_VR_SET_EEPROM_PARAMETERS)
return False
else:
return True
def GetPower(self, ChNumber=1):
'''
Set frequency of the channel ChNumber of the PWM equipment
The return power is expressed in the unit defined by the GetUnit() method
ChNumber is the channel number : 1 (default) or 2
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Constantes import APXXXX_ERROR_VARIABLE_NOT_DEFINED
from PyApex.Constantes import SimuPWM_Power_dBm, SimuPWM_Power_mW
from PyApex.Errors import ApexError
try:
ChNumber = int(ChNumber)
except:
self.__Connexion.close()
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "ChNumber")
else:
if ChNumber > len(self.__Channels):
print("PyApex Warning. PWM Channel is set to 1 !")
ChNumber = 1
if self.__Simulation:
if self.__Unit.lower() == "dbm":
Power = SimuPWM_Power_dBm
elif self.__Unit.lower() == "mw":
Power = SimuPWM_Power_mW
else:
self.__Connexion.close()
raise ApexError(APXXXX_ERROR_VARIABLE_NOT_DEFINED,
"self.__Unit")
else:
if self.__Unit.lower() == "dbm":
Command = "POW[" + str(self.__SlotNumber).zfill(2) + "]:DBM[" + \
str(ChNumber) + "]?\n"
elif self.__Unit.lower() == "mw":
Command = "POW[" + str(self.__SlotNumber).zfill(2) + "]:MW[" + \
str(ChNumber) + "]?\n"
else:
self.__Connexion.close()
raise ApexError(APXXXX_ERROR_VARIABLE_NOT_DEFINED,
"self.__Unit")
Send(self.__Connexion, Command)
Power = Receive(self.__Connexion)
return float(Power[:-1])
def SlotType(self, SlotNumber, Type="string"):
'''
Return a description of the module in the slot 'SlotNumber'
If Type = 'string' or 'str' or 's', the function returns a string (default)
If Type = 'integer' or 'int' or 'i', the function returns the module number type
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Constantes import AP1000_SLOT_MIN, AP1000_SLOT_MAX
from PyApex.Constantes import AP1000_ERROR_SLOT_NOT_DEFINED, SimuAP1000_SlotID, Modules
from PyApex.Errors import ApexError
from random import sample
import re
if not isinstance(SlotNumber, int):
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "SlotNumber")
sys.exit()
if SlotNumber < AP1000_SLOT_MIN or SlotNumber > AP1000_SLOT_MAX:
raise ApexError(APXXXX_ERROR_ARGUMENT_VALUE, "SlotNumber")
sys.exit()
if not isinstance(Type, str):
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "Type")
sys.exit()
Type = Type.lower()
if self.__Simulation:
ID = sample(list(Modules), 1)
return Modules[ID[0]]
else:
if self.SlotUsed(SlotNumber):
ID = self.SlotID(SlotNumber)
else:
return "Slot not used"
try:
ID = ID.lower().split("/")[1].split("-")[0]
ID = int(re.findall("\d+", ID)[0])
if Type == "integer" or Type == "int" or Type == "i":
return ID
else:
return Modules[ID]
except:
print("PyApex Warning. Slot", SlotNumber, "not defined")
def SetYResolution(self, Resolution):
'''
Set the Y-axis power per division value
Resolution is expressed in the value of 'ScaleYUnit'
'''
from PyApex.Constantes import APXXXX_ERROR_ARGUMENT_TYPE, APXXXX_ERROR_ARGUMENT_VALUE
from PyApex.Constantes import AP2XXX_MINYRES, AP2XXX_MAXYRES
from PyApex.Errors import ApexError
if not isinstance(Resolution, (float, int)):
raise ApexError(APXXXX_ERROR_ARGUMENT_TYPE, "Resolution")
sys.exit()
if Resolution < AP2XXX_MINYRES or Resolution > AP2XXX_MAXYRES:
raise ApexError(APXXXX_ERROR_ARGUMENT_VALUE, "Resolution")
sys.exit()
if not self.__Simulation:
Command = "SPDIVY" + str(Resolution) + "\n"
Send(self.__Connexion, Command)
