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)