From 804e83be3ee8d742830b5571f3de52f39dbea24f Mon Sep 17 00:00:00 2001 From: xansmolzy Date: Fri, 21 Nov 2025 21:00:41 +0100 Subject: [PATCH] add 0.1 rev --- __init__.py | 43 ++ equipment/multimeter/md_sourcefiles/3458A.md | 139 +++++ .../oscilloscope/md_sourcefiles/DS1054Z.md | 284 +++++++++ .../oscilloscope/py_generated/DS1054Z.py | 541 ++++++++++++++++++ .../__pycache__/DS1054Z.cpython-312.pyc | Bin 0 -> 61035 bytes generator.py | 88 +++ supported_devices.json | 7 + 7 files changed, 1102 insertions(+) create mode 100644 __init__.py create mode 100644 equipment/multimeter/md_sourcefiles/3458A.md create mode 100644 equipment/oscilloscope/md_sourcefiles/DS1054Z.md create mode 100644 equipment/oscilloscope/py_generated/DS1054Z.py create mode 100644 equipment/oscilloscope/py_generated/__pycache__/DS1054Z.cpython-312.pyc create mode 100644 generator.py create mode 100644 supported_devices.json diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..b086695 --- /dev/null +++ b/__init__.py @@ -0,0 +1,43 @@ +import json +import sys + +def instrument(pyvisa_instrument_address, device_handle): + """ + Create an instance + + Args: + instrument_handle (Pyvisa Object): Input Pyvisa Object linked to target device. + device_handle (String): Input String indicating the make of the instrument. + + Returns: + Object: Object of the device with bare essential interface commands. + """ + # load the known devices json + handle_exists_flag = 0 + module_obj = [] + + f = open('supported_devices.json') + allowed_handles = json.load(f) + for handle in allowed_handles['supported_instruments']: + # If handle found, create object + if handle["make"] == device_handle: + handle_exists_flag = 1 + # load the right instrument module and save as global import + try: + sys.path.append(f"equipment/{handle["type"]}/py_generated/") + module_obj = __import__(f'{handle["make"]}') + module_obj = eval(f'module_obj.{handle["make"]}("{pyvisa_instrument_address}","{device_handle}")') + except: + raise ValueError(f'[MeasKit] Invalid \"{device_handle}\" instrument class.') + break + # If similar handle, warn user + elif handle["make"].lower() == device_handle.lower(): + tmp = handle["make"] + print(f'[MeasKit] Similarely capitalized device handle found. Handle \"{device_handle}\" was queried for but \"{tmp}\" was found.') + f.close() + # If no exactly matching handles found error + if not handle_exists_flag: + raise ValueError(f'[MeasKit] Device handle \"{device_handle}\" not supported yet.') + # waste some resources in the mem heap, investigate removing these + return module_obj + diff --git a/equipment/multimeter/md_sourcefiles/3458A.md b/equipment/multimeter/md_sourcefiles/3458A.md new file mode 100644 index 0000000..bf4f8f3 --- /dev/null +++ b/equipment/multimeter/md_sourcefiles/3458A.md @@ -0,0 +1,139 @@ +# LIBRARY COMMANDS + +- MEAS_MODE(input) + 3. FUNC(input) + +- MEAS_RANGE(input) + 3. RANG(input) + +- AUTO_ZERO(input) + 3. AZERO(input) + +- ACQUISITION_TIME(input) + 3. NPLC(input) + +- RESOLUTION(input) + 3. NDIG(input) + +- MEAS_CONF(func,range,nplc,azero) + 1. sets basic measurement partameters + 3. FUNC(func) + 3. RANG(range) + 3. AZERO(nplc) + 3. NPLC(azero) + 3. NDIG('MAX') + +- MEASURE() + 1. measures single sample + 3. TARM('HOLD') + 3. TARM('SGL') + 3. PAUSE + 3. READ + +- MEASURE_NSAMPLES(nsamples) + 1. measures samples in the background and store into memory + 3. TARM('HOLD') + 3. MEM('FIFO') + 3. NRDGS(nsamples,'AUTO') + +- RECALL_NSAMPLES(nsamples) + 1. recalls measured samples in the background and recall from memory + 3. RMEM(1,nsamples) + 3. READ + +# SETTEABLE PARAMETERS +- ACAL +- ACBAND +- ADDRESS +- APER +- ARANGE +- AZERO +- BEEP +- CAL +- CALL +- CALSTR +- COMPRESS +- CONT +- CSB +- DEFEAT +- DEFKEY +- DELAY +- DELSUB +- DIAGNOST +- DISP +- EMASK +- END +- EXTOUT +- FIXEDZ +- FREQ +- FSOURCE +- FUNC + 1. sets the measurement mode to be used + 2. DCV|ACV|ACDCV|OHM|OHMF|DCI|ACI|ACDCI|FREQ|PER|DSAC|DSDC|SSAC|SSDC +- INBUF +- LEVEL +- LFILTER +- LFREQ +- LOCK +- MATH +- MEM + 1. sets the storage mode of the internal memory + 2. LIFO|FIFO|OFF +- MENU +- MFORMAT +- MMATH +- MSIZE +- NDIG +- NPLC +- NRDGS +- OCOMP +- OFORMAT +- PAUSE +- PER +- PRESET +- PURGE +- QFORMAT +- R +- RANG + 1. sets the range + 2. 0.1|1|10|100|1000|10000|100000|1000000|10000000|100000000|1000000000|AUTO +- RATIO +- RES +- RESET +- RMATH +- RQS +- RSTATE +- SCAL +- SCRATCH +- SECURE +- SETACV +- SLOPE +- SMATH +- SRQ +- SSTATE +- SUB +- SUBEND +- SWEEP +- T +- TARM +- TBUFF +- TERM +- TEST +- TIMER +- TONE +- TRIG + +# GETTEABLE PARAMETERS +- AUXERR? +- CALNUM? +- ERR? +- ERRSTR? +- ID? +- ISCALE? +- LINE? +- MCOUNT? +- OPT? +- REV? +- SSPARAM? +- STB? +- TEMP? \ No newline at end of file diff --git a/equipment/oscilloscope/md_sourcefiles/DS1054Z.md b/equipment/oscilloscope/md_sourcefiles/DS1054Z.md new file mode 100644 index 0000000..5fea07c --- /dev/null +++ b/equipment/oscilloscope/md_sourcefiles/DS1054Z.md @@ -0,0 +1,284 @@ +# LIBRARY COMMANDS + +- CONF_CHANNEL(channel,state,range,bandwidth,coupling) + 1. recalls measured samples in the background and recall from memory + 2. RMEM(1,nsamples) + 3. READ + +- CONF_TRIGGER(channel,state,range,bandwidth,coupling) + 1. recalls measured samples in the background and recall from memory + 2. RMEM(1,nsamples) + 3. READ + +# SETTEABLE PARAMETERS +- :AUToscale +- :CLEar +- :RUN +- :STOP +- :SINGle +- :TFORce +- :ACQuire:AVERages +- :ACQuire:MDEPth +- :ACQuire:TYPE +- :CALibrate:QUIT +- :CALibrate:STARt +- :CHANnel:BWLimit +- :CHANnel:COUPling +- :CHANnel:DISPlay +- :CHANnel:INVert +- :CHANnel:OFFSet +- :CHANnel:RANGe +- :CHANnel:TCAL +- :CHANnel:SCALe +- :CHANnel:PROBe +- :CHANnel:UNITs +- :CHANnel:VERNier +- :CURSor:MODE +- :CURSor:MANual +- :CURSor:TRACk +- :CURSor:AUTO +- :CURSor:XY +- :DECoder:MODE +- :DECoder:DISPlay +- :DECoder:FORMat +- :DECoder:POSition +- :DECoder:THREshold:CHANnel1 +- :DECoder:THREshold:CHANnel2 +- :DECoder:THREshold:CHANnel3 +- :DECoder:THREshold:CHANnel4 +- :DECoder:THREshold:AUTO +- :DECoder:CONFig:LABel +- :DECoder:CONFig:LINE +- :DECoder:CONFig:FORMat +- :DECoder:CONFig:ENDian +- :DECoder:CONFig:WIDth +- :DECoder:UART +- :DECoder:IIC +- :DECoder:SPI +- :DECoder:PARallel +- :DISPlay:CLEar +- :DISPlay:TYPE +- :DISPlay:GRADing:TIME +- :DISPlay:WBRightness +- :DISPlay:GRID +- :DISPlay:GBRightness +- :ETABle Commands +- :ETABle:DISP +- :ETABle:FORMat +- :ETABle:VIEW +- :ETABle:COLumn +- :ETABle:ROW +- :ETABle:SORT +- :FUNCtion:WRECord:FEND +- :FUNCtion:WRECord:FINTerval +- :FUNCtion:WRECord:PROMpt +- :FUNCtion:WRECord:OPERate +- :FUNCtion:WRECord:ENABle +- :FUNCtion:WREPlay:FSTart +- :FUNCtion:WREPlay:FEND +- :FUNCtion:WREPlay:FMAX? +- :FUNCtion:WREPlay:FINTerval +- :FUNCtion:WREPlay:MODE +- :FUNCtion:WREPlay:DIRection +- :FUNCtion:WREPlay:OPERate +- :FUNCtion:WREPlay:FCURrent +- *CLS +- *ESE +- *OPC +- *RST +- *SRE +- *WAI +- :LA:ACTive +- :LA:AUTosort +- :LA:DIGital:DISPlay +- :LA:DIGital:POSition +- :LA:DIGital:LABel +- :LA:DISPlay +- :LA:POD:DISPlay +- :LA:POD:THReshold +- :LA:SIZE +- :LA:STATe +- :LA:TCALibrate +- :LAN:DHCP +- :LAN:AUToip +- :LAN:GATeway +- :LAN:DNS +- :LAN:MANual +- :LAN:INITiate +- :LAN:IPADdress +- :LAN:SMASk +- :LAN:APPLy +- :MATH:DISPlay +- :MATH:OPERator +- :MATH:SOURce1 +- :MATH:SOURce2 +- :MATH:LSOUrce1 +- :MATH:LSOUrce2 +- :MATH:SCALe +- :MATH:OFFSet +- :MATH:INVert +- :MATH:RESet +- :MATH:FFT:SOURce +- :MATH:FFT:WINDow +- :MATH:FFT:SPLit +- :MATH:FFT:UNIT +- :MATH:FFT:HSCale +- :MATH:FFT:HCENter +- :MATH:FFT:MODE +- :MATH:FILTer:TYPE +- :MATH:FILTer:W1 +- :MATH:FILTer:W2 +- :MATH:OPTion:STARt +- :MATH:OPTion:END +- :MATH:OPTion:INVert +- :MATH:OPTion:SENSitivity +- :MATH:OPTion:DIStance +- :MATH:OPTion:ASCale +- :MATH:OPTion:THReshold1 +- :MATH:OPTion:THReshold2 +- :MATH:OPTion:FX:SOURce1 +- :MATH:OPTion:FX:SOURce2 +- :MATH:OPTion:FX:OPERator +- :MASK:ENABle +- :MASK:SOURce +- :MASK:OPERate +- :MASK:MDISplay +- :MASK:SOOutput +- :MASK:OUTPut +- :MASK:X +- :MASK:Y +- :MASK:CREate +- :MASK:RESet +- :MEASure:SOURce +- :MEASure:COUNter:SOURce +- :MEASure:CLEar +- :MEASure:RECover +- :MEASure:ADISplay +- :MEASure:AMSource +- :MEASure:SETup:MAX +- :MEASure:SETup:MID +- :MEASure:SETup:MIN +- :MEASure:SETup:PSA +- :MEASure:SETup:PSB +- :MEASure:SETup:DSA +- :MEASure:SETup:DSB +- :MEASure:STATistic:DISPlay +- :MEASure:STATistic:MODE +- :MEASure:STATistic:RESet +- :MEASure:STATistic:ITEM +- :MEASure:ITEM +- :REFerence:DISPlay +- :REFerence:ENABle +- :REFerence:SOURce +- :REFerence:VSCale +- :REFerence:VOFFset +- :REFerence:RESet +- :REFerence:CURRent +- :REFerence:SAVe +- :REFerence:COLor +- :SOURce[]:OUTPut[][:STATe] +- :SOURce[]:OUTPut[]:IMPedance +- :SOURce[]:FREQuency[:FIXed] +- :SOURce[]:PHASe[:ADJust] +- :SOURce[]:PHASe:INITiate +- :SOURce[]:FUNCtion[:SHAPe] +- :SOURce[]:FUNCtion:RAMP:SYMMetry +- :SOURce[]:VOLTage[:LEVel][:IMMediate][:AMPLitude] +- :SOURce[]:VOLTage[:LEVel][:IMMediate]:OFFSet +- :SOURce[]:PULSe:DCYCle +- :SOURce[]:MOD[:STATe] +- :SOURce[]:MOD:TYPe +- :SOURce[]:MOD:AM[:DEPTh] +- :SOURce[]:MOD:AM:INTernal:FREQuency +- :SOURce[]:MOD:FM:INTernal:FREQuency +- :SOURce[]:MOD:AM:INTernal:FUNCtion +- :SOURce[]:MOD:FM:INTernal:FUNCtion +- :SOURce[]:MOD:FM[:DEVIation] +- :SOURce[]:APPLy:NOISe +- :SOURce[]:APPLy:PULSe +- :SOURce[]:APPLy:RAMP +- :SOURce[]:APPLy:SINusoid +- :SOURce[]:APPLy:SQUare +- :SOURce[]:APPLy:USER +- :STORage +- :STORage:IMAGe:TYPE +- :STORage:IMAGe:INVERT +- :STORage:IMAGe:COLor +- :SYSTem +- :SYSTem:AUToscale +- :SYSTem:GAM? +- :SYSTem:LANGuage +- :SYSTem:LOCKed +- :SYSTem:PON +- :SYSTem:OPTion:INSTall +- :SYSTem:OPTion:UNINSTall +- :SYSTem:RAM? +- :SYSTem:SETup +- :TRACe[] +- :TRACe[]:DATA +- :TRACe[]:DATA:DAC16 +- :TRACe[]:DATA:DAC +- :TRACe[]:DATA:POINts +- :TRACe[]:DATA:POINts:INTerpolate +- :TRACe[]:DATA:VALue +- :TRACe[]:DATA:LOAD? +- :TIMebase:DELay:ENABle +- :TIMebase:DELay:OFFSet +- :TIMebase:DELay:SCALe +- :TIMebase[:MAIN]:OFFSet +- :TIMebase[:MAIN]:SCALe +- :TIMebase:MODE +- :TRIGger:MODE +- :TRIGger:COUPling +- :TRIGger:SWEep +- :TRIGger:HOLDoff +- :TRIGger:NREJect +- :TRIGger:EDGe +- :TRIGger:PULSe +- :TRIGger:SLOPe +- :TRIGger:VIDeo +- :TRIGger:PATTern +- :TRIGger:DURATion +- :TRIGger:TIMeout +- :TRIGger:RUNT +- :TRIGger:WINDows +- :TRIGger:DELay +- :TRIGger:SHOLd +- :TRIGger:NEDGe +- :TRIGger:RS232 +- :TRIGger:IIC +- :TRIGger:SPI +- :WAVeform:STARt +- :WAVeform:STOP +- :WAVeform:SOURce +- :WAVeform:MODE +- :WAVeform:FORMat + +# GETTEABLE PARAMETERS +- :LAN:STATus? +- :LAN:VISA? +- :WAVeform:DATA? +- :WAVeform:XINCrement? +- :WAVeform:XORigin? +- :WAVeform:XREFerence? +- :WAVeform:YINCrement? +- :WAVeform:YORigin? +- :WAVeform:YREFerence? +- :WAVeform:PREamble? +- :TRIGger:POSition? +- :SYSTem:ERRor[:NEXT]? +- [:SOURce[]]:APPLy? +- :FUNCtion:WRECord:FMAX? +- *ESR? +- *IDN? +- *STB? +- *TST? +- :LAN:MAC? +- :MASK:PASSed? +- :MASK:FAILed? +- :MASK:TOTal? +- :MEASure:COUNter:VALue? +- :ACQuire:SRATe? +- :ETABle:DATA? +- :DISPlay:DATA? +- :DECoder:CONFig:SRATe? \ No newline at end of file diff --git a/equipment/oscilloscope/py_generated/DS1054Z.py b/equipment/oscilloscope/py_generated/DS1054Z.py new file mode 100644 index 0000000..ee51b5a --- /dev/null +++ b/equipment/oscilloscope/py_generated/DS1054Z.py @@ -0,0 +1,541 @@ +import pyvisa + +class DS1054Z(object): + def __init__(self, pyvisa_instrument_address, device_handle): + # initiate correct device class and pass pyvisa handle + self.pyvisa_instrument_address = pyvisa_instrument_address + self.pyvisa_instrument_manager = pyvisa.ResourceManager() + self.pyvisa_instrument_object = self.pyvisa_instrument_manager.open_resource(pyvisa_instrument_address) + self.pyvisa_instrument_object = self.pyvisa_instrument_object + self.device_handle = device_handle + print(f"[MeasKit] started control class instance for {device_handle} at {pyvisa_instrument_address}.") + def conf_channel(self,channel,state,range,bandwidth,coupling): + '''Configures a singular Channel''' + self.CHANneln_DISPlay(channel, state) + self.CHANneln_RANGe(channel, range) + self.CHANneln_BWLimit(channel, range) + self.CHANneln_COUPling(channel, coupling) + def conf_trigger(self,mode,level,pos_neg,n_edge = 1): + '''sets up trigger on nth falling/rising edge''' + self.TRIGger_MODE('NEDG') + self.TRIGger_NEDGe_LEVel(level) + self.TRIGger_NEDGe_EDGE(n_edge) + self.TRIGger_NEDGe_SLOPe(pos_neg) + def conf_timebase(self,time_div,timebase_skew): + '''sets up timebase''' + self.TIMebase_MAIN_SCALe(time_div) + self.TIMebase_MAIN_OFFSet(timebase_skew) + def send_trigger(self,single_force = "SINGle"): + '''send trig''' + if "FOR" in single_force.upper(): + self.TFORce() + else: + self.SINGle() + def get_data(self,channel): + '''get data from channel''' + self.WAVeform_SOURce(channel) + self.WAVeform_MODE('RAW') + self.WAVeform_FORMat('ASCii') + return self.WAVeform_DATA() + + def AUToscale(self, input = None): + self.pyvisa_instrument_object.write(f':AUToscale {str(input)}') + def CLEar(self, input = None): + self.pyvisa_instrument_object.write(f':CLEar {str(input)}') + def RUN(self, input = None): + self.pyvisa_instrument_object.write(f':RUN {str(input)}') + def STOP(self, input = None): + self.pyvisa_instrument_object.write(f':STOP {str(input)}') + def SINGle(self, input = None): + self.pyvisa_instrument_object.write(f':SINGle {str(input)}') + def TFORce(self, input = None): + self.pyvisa_instrument_object.write(f':TFORce {str(input)}') + def ACQuire_AVERages(self, input = None): + self.pyvisa_instrument_object.write(f':ACQuire:AVERages {str(input)}') + def ACQuire_MDEPth(self, input = None): + self.pyvisa_instrument_object.write(f':ACQuire:MDEPth {str(input)}') + def ACQuire_TYPE(self, input = None): + self.pyvisa_instrument_object.write(f':ACQuire:TYPE {str(input)}') + def CALibrate_QUIT(self, input = None): + self.pyvisa_instrument_object.write(f':CALibrate:QUIT {str(input)}') + def CALibrate_STARt(self, input = None): + self.pyvisa_instrument_object.write(f':CALibrate:STARt {str(input)}') + def CHANneln_BWLimit(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':CHANnel{str(channel)}:BWLimit {str(input)}') + def CHANneln_COUPling(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':CHANnel{str(channel)}:COUPling {str(input)}') + def CHANneln_DISPlay(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':CHANnel{str(channel)}:DISPlay {str(input)}') + def CHANneln_INVert(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':CHANnel{str(channel)}:INVert {str(input)}') + def CHANneln_OFFSet(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':CHANnel{str(channel)}:OFFSet {str(input)}') + def CHANneln_RANGe(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':CHANnel{str(channel)}:RANGe {str(input)}') + def CHANneln_TCAL(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':CHANnel{str(channel)}:TCAL {str(input)}') + def CHANneln_SCALe(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':CHANnel{str(channel)}:SCALe {str(input)}') + def CHANneln_PROBe(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':CHANnel{str(channel)}:PROBe {str(input)}') + def CHANneln_UNITs(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':CHANnel{str(channel)}:UNITs {str(input)}') + def CHANneln_VERNier(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':CHANnel{str(channel)}:VERNier {str(input)}') + def CURSor_MODE(self, input = None): + self.pyvisa_instrument_object.write(f':CURSor:MODE {str(input)}') + def CURSor_MANual(self, input = None): + self.pyvisa_instrument_object.write(f':CURSor:MANual {str(input)}') + def CURSor_TRACk(self, input = None): + self.pyvisa_instrument_object.write(f':CURSor:TRACk {str(input)}') + def CURSor_AUTO(self, input = None): + self.pyvisa_instrument_object.write(f':CURSor:AUTO {str(input)}') + def CURSor_XY(self, input = None): + self.pyvisa_instrument_object.write(f':CURSor:XY {str(input)}') + def DECodern_MODE(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:MODE {str(input)}') + def DECodern_DISPlay(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:DISPlay {str(input)}') + def DECodern_FORMat(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:FORMat {str(input)}') + def DECodern_POSition(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:POSition {str(input)}') + def DECodern_THREshold_CHANnel1(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:THREshold:CHANnel1 {str(input)}') + def DECodern_THREshold_CHANnel2(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:THREshold:CHANnel2 {str(input)}') + def DECodern_THREshold_CHANnel3(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:THREshold:CHANnel3 {str(input)}') + def DECodern_THREshold_CHANnel4(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:THREshold:CHANnel4 {str(input)}') + def DECodern_THREshold_AUTO(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:THREshold:AUTO {str(input)}') + def DECodern_CONFig_LABel(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:CONFig:LABel {str(input)}') + def DECodern_CONFig_LINE(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:CONFig:LINE {str(input)}') + def DECodern_CONFig_FORMat(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:CONFig:FORMat {str(input)}') + def DECodern_CONFig_ENDian(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:CONFig:ENDian {str(input)}') + def DECodern_CONFig_WIDth(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:CONFig:WIDth {str(input)}') + def DECodern_UART(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:UART {str(input)}') + def DECodern_IIC(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:IIC {str(input)}') + def DECodern_SPI(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:SPI {str(input)}') + def DECodern_PARallel(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':DECoder{str(channel)}:PARallel {str(input)}') + def DISPlay_CLEar(self, input = None): + self.pyvisa_instrument_object.write(f':DISPlay:CLEar {str(input)}') + def DISPlay_TYPE(self, input = None): + self.pyvisa_instrument_object.write(f':DISPlay:TYPE {str(input)}') + def DISPlay_GRADing_TIME(self, input = None): + self.pyvisa_instrument_object.write(f':DISPlay:GRADing:TIME {str(input)}') + def DISPlay_WBRightness(self, input = None): + self.pyvisa_instrument_object.write(f':DISPlay:WBRightness {str(input)}') + def DISPlay_GRID(self, input = None): + self.pyvisa_instrument_object.write(f':DISPlay:GRID {str(input)}') + def DISPlay_GBRightness(self, input = None): + self.pyvisa_instrument_object.write(f':DISPlay:GBRightness {str(input)}') + def ETABleCommands(self, input = None): + self.pyvisa_instrument_object.write(f':ETABle Commands {str(input)}') + def ETABlen_DISP(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':ETABle{str(channel)}:DISP {str(input)}') + def ETABlen_FORMat(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':ETABle{str(channel)}:FORMat {str(input)}') + def ETABlen_VIEW(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':ETABle{str(channel)}:VIEW {str(input)}') + def ETABlen_COLumn(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':ETABle{str(channel)}COLumn {str(input)}') + def ETABlen_ROW(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':ETABle{str(channel)}:ROW {str(input)}') + def ETABlen_SORT(self, channel = None, input = None): + self.pyvisa_instrument_object.write(f':ETABle{str(channel)}:SORT {str(input)}') + def FUNCtion_WRECord_FEND(self, input = None): + self.pyvisa_instrument_object.write(f':FUNCtion:WRECord:FEND {str(input)}') + def FUNCtion_WRECord_FINTerval(self, input = None): + self.pyvisa_instrument_object.write(f':FUNCtion:WRECord:FINTerval {str(input)}') + def FUNCtion_WRECord_PROMpt(self, input = None): + self.pyvisa_instrument_object.write(f':FUNCtion:WRECord:PROMpt {str(input)}') + def FUNCtion_WRECord_OPERate(self, input = None): + self.pyvisa_instrument_object.write(f':FUNCtion:WRECord:OPERate {str(input)}') + def FUNCtion_WRECord_ENABle(self, input = None): + self.pyvisa_instrument_object.write(f':FUNCtion:WRECord:ENABle {str(input)}') + def FUNCtion_WREPlay_FSTart(self, input = None): + self.pyvisa_instrument_object.write(f':FUNCtion:WREPlay:FSTart {str(input)}') + def FUNCtion_WREPlay_FEND(self, input = None): + self.pyvisa_instrument_object.write(f':FUNCtion:WREPlay:FEND {str(input)}') + def FUNCtion_WREPlay_FMAX(self, input = None): + self.pyvisa_instrument_object.write(f':FUNCtion:WREPlay:FMAX? {str(input)}') + def FUNCtion_WREPlay_FINTerval(self, input = None): + self.pyvisa_instrument_object.write(f':FUNCtion:WREPlay:FINTerval {str(input)}') + def FUNCtion_WREPlay_MODE(self, input = None): + self.pyvisa_instrument_object.write(f':FUNCtion:WREPlay:MODE {str(input)}') + def FUNCtion_WREPlay_DIRection(self, input = None): + self.pyvisa_instrument_object.write(f':FUNCtion:WREPlay:DIRection {str(input)}') + def FUNCtion_WREPlay_OPERate(self, input = None): + self.pyvisa_instrument_object.write(f':FUNCtion:WREPlay:OPERate {str(input)}') + def FUNCtion_WREPlay_FCURrent(self, input = None): + self.pyvisa_instrument_object.write(f':FUNCtion:WREPlay:FCURrent {str(input)}') + def CLS(self, input = None): + self.pyvisa_instrument_object.write(f'*CLS {str(input)}') + def ESE(self, input = None): + self.pyvisa_instrument_object.write(f'*ESE {str(input)}') + def OPC(self, input = None): + self.pyvisa_instrument_object.write(f'*OPC {str(input)}') + def RST(self, input = None): + self.pyvisa_instrument_object.write(f'*RST {str(input)}') + def SRE(self, input = None): + self.pyvisa_instrument_object.write(f'*SRE {str(input)}') + def WAI(self, input = None): + self.pyvisa_instrument_object.write(f'*WAI {str(input)}') + def LAN_DHCP(self, input = None): + self.pyvisa_instrument_object.write(f':LAN:DHCP {str(input)}') + def LAN_AUToip(self, input = None): + self.pyvisa_instrument_object.write(f':LAN:AUToip {str(input)}') + def LAN_GATeway(self, input = None): + self.pyvisa_instrument_object.write(f':LAN:GATeway {str(input)}') + def LAN_DNS(self, input = None): + self.pyvisa_instrument_object.write(f':LAN:DNS {str(input)}') + def LAN_MANual(self, input = None): + self.pyvisa_instrument_object.write(f':LAN:MANual {str(input)}') + def LAN_INITiate(self, input = None): + self.pyvisa_instrument_object.write(f':LAN:INITiate {str(input)}') + def LAN_IPADdress(self, input = None): + self.pyvisa_instrument_object.write(f':LAN:IPADdress {str(input)}') + def LAN_SMASk(self, input = None): + self.pyvisa_instrument_object.write(f':LAN:SMASk {str(input)}') + def LAN_APPLy(self, input = None): + self.pyvisa_instrument_object.write(f':LAN:APPLy {str(input)}') + def MATH_DISPlay(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:DISPlay {str(input)}') + def MATH_OPERator(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:OPERator {str(input)}') + def MATH_SOURce1(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:SOURce1 {str(input)}') + def MATH_SOURce2(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:SOURce2 {str(input)}') + def MATH_LSOUrce1(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:LSOUrce1 {str(input)}') + def MATH_LSOUrce2(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:LSOUrce2 {str(input)}') + def MATH_SCALe(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:SCALe {str(input)}') + def MATH_OFFSet(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:OFFSet {str(input)}') + def MATH_INVert(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:INVert {str(input)}') + def MATH_RESet(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:RESet {str(input)}') + def MATH_FFT_SOURce(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:FFT:SOURce {str(input)}') + def MATH_FFT_WINDow(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:FFT:WINDow {str(input)}') + def MATH_FFT_SPLit(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:FFT:SPLit {str(input)}') + def MATH_FFT_UNIT(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:FFT:UNIT {str(input)}') + def MATH_FFT_HSCale(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:FFT:HSCale {str(input)}') + def MATH_FFT_HCENter(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:FFT:HCENter {str(input)}') + def MATH_FFT_MODE(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:FFT:MODE {str(input)}') + def MATH_FILTer_TYPE(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:FILTer:TYPE {str(input)}') + def MATH_FILTer_W1(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:FILTer:W1 {str(input)}') + def MATH_FILTer_W2(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:FILTer:W2 {str(input)}') + def MATH_OPTion_STARt(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:OPTion:STARt {str(input)}') + def MATH_OPTion_END(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:OPTion:END {str(input)}') + def MATH_OPTion_INVert(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:OPTion:INVert {str(input)}') + def MATH_OPTion_SENSitivity(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:OPTion:SENSitivity {str(input)}') + def MATH_OPTion_DIStance(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:OPTion:DIStance {str(input)}') + def MATH_OPTion_ASCale(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:OPTion:ASCale {str(input)}') + def MATH_OPTion_THReshold1(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:OPTion:THReshold1 {str(input)}') + def MATH_OPTion_THReshold2(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:OPTion:THReshold2 {str(input)}') + def MATH_OPTion_FX_SOURce1(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:OPTion:FX:SOURce1 {str(input)}') + def MATH_OPTion_FX_SOURce2(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:OPTion:FX:SOURce2 {str(input)}') + def MATH_OPTion_FX_OPERator(self, input = None): + self.pyvisa_instrument_object.write(f':MATH:OPTion:FX:OPERator {str(input)}') + def MASK_ENABle(self, input = None): + self.pyvisa_instrument_object.write(f':MASK:ENABle {str(input)}') + def MASK_SOURce(self, input = None): + self.pyvisa_instrument_object.write(f':MASK:SOURce {str(input)}') + def MASK_OPERate(self, input = None): + self.pyvisa_instrument_object.write(f':MASK:OPERate {str(input)}') + def MASK_MDISplay(self, input = None): + self.pyvisa_instrument_object.write(f':MASK:MDISplay {str(input)}') + def MASK_SOOutput(self, input = None): + self.pyvisa_instrument_object.write(f':MASK:SOOutput {str(input)}') + def MASK_OUTPut(self, input = None): + self.pyvisa_instrument_object.write(f':MASK:OUTPut {str(input)}') + def MASK_X(self, input = None): + self.pyvisa_instrument_object.write(f':MASK:X {str(input)}') + def MASK_Y(self, input = None): + self.pyvisa_instrument_object.write(f':MASK:Y {str(input)}') + def MASK_CREate(self, input = None): + self.pyvisa_instrument_object.write(f':MASK:CREate {str(input)}') + def MASK_RESet(self, input = None): + self.pyvisa_instrument_object.write(f':MASK:RESet {str(input)}') + def MEASure_SOURce(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:SOURce {str(input)}') + def MEASure_COUNter_SOURce(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:COUNter:SOURce {str(input)}') + def MEASure_CLEar(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:CLEar {str(input)}') + def MEASure_RECover(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:RECover {str(input)}') + def MEASure_ADISplay(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:ADISplay {str(input)}') + def MEASure_AMSource(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:AMSource {str(input)}') + def MEASure_SETup_MAX(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:SETup:MAX {str(input)}') + def MEASure_SETup_MID(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:SETup:MID {str(input)}') + def MEASure_SETup_MIN(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:SETup:MIN {str(input)}') + def MEASure_SETup_PSA(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:SETup:PSA {str(input)}') + def MEASure_SETup_PSB(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:SETup:PSB {str(input)}') + def MEASure_SETup_DSA(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:SETup:DSA {str(input)}') + def MEASure_SETup_DSB(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:SETup:DSB {str(input)}') + def MEASure_STATistic_DISPlay(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:STATistic:DISPlay {str(input)}') + def MEASure_STATistic_MODE(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:STATistic:MODE {str(input)}') + def MEASure_STATistic_RESet(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:STATistic:RESet {str(input)}') + def MEASure_STATistic_ITEM(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:STATistic:ITEM {str(input)}') + def MEASure_ITEM(self, input = None): + self.pyvisa_instrument_object.write(f':MEASure:ITEM {str(input)}') + def REFerence_DISPlay(self, input = None): + self.pyvisa_instrument_object.write(f':REFerence:DISPlay {str(input)}') + def REFerencen_ENABle(self, input = None): + self.pyvisa_instrument_object.write(f':REFerence:ENABle {str(input)}') + def REFerencen_SOURce(self, input = None): + self.pyvisa_instrument_object.write(f':REFerence:SOURce {str(input)}') + def REFerencen_VSCale(self, input = None): + self.pyvisa_instrument_object.write(f':REFerence:VSCale {str(input)}') + def REFerencen_VOFFset(self, input = None): + self.pyvisa_instrument_object.write(f':REFerence:VOFFset {str(input)}') + def REFerencen_RESet(self, input = None): + self.pyvisa_instrument_object.write(f':REFerence:RESet {str(input)}') + def REFerencen_CURRent(self, input = None): + self.pyvisa_instrument_object.write(f':REFerence:CURRent {str(input)}') + def REFerencen_SAVe(self, input = None): + self.pyvisa_instrument_object.write(f':REFerence:SAVe {str(input)}') + def REFerencen_COLor(self, input = None): + self.pyvisa_instrument_object.write(f':REFerence:COLor {str(input)}') + def STORage(self, input = None): + self.pyvisa_instrument_object.write(f':STORage {str(input)}') + def STORage_IMAGe_TYPE(self, input = None): + self.pyvisa_instrument_object.write(f':STORage:IMAGe:TYPE {str(input)}') + def STORage_IMAGe_INVERT(self, input = None): + self.pyvisa_instrument_object.write(f':STORage:IMAGe:INVERT {str(input)}') + def STORage_IMAGe_COLor(self, input = None): + self.pyvisa_instrument_object.write(f':STORage:IMAGe:COLor {str(input)}') + def SYSTem(self, input = None): + self.pyvisa_instrument_object.write(f':SYSTem {str(input)}') + def SYSTem_AUToscale(self, input = None): + self.pyvisa_instrument_object.write(f':SYSTem:AUToscale {str(input)}') + def SYSTem_GAM(self, input = None): + self.pyvisa_instrument_object.write(f':SYSTem:GAM? {str(input)}') + def SYSTem_LANGuage(self, input = None): + self.pyvisa_instrument_object.write(f':SYSTem:LANGuage {str(input)}') + def SYSTem_LOCKed(self, input = None): + self.pyvisa_instrument_object.write(f':SYSTem:LOCKed {str(input)}') + def SYSTem_PON(self, input = None): + self.pyvisa_instrument_object.write(f':SYSTem:PON {str(input)}') + def SYSTem_OPTion_INSTall(self, input = None): + self.pyvisa_instrument_object.write(f':SYSTem:OPTion:INSTall {str(input)}') + def SYSTem_OPTion_UNINSTall(self, input = None): + self.pyvisa_instrument_object.write(f':SYSTem:OPTion:UNINSTall {str(input)}') + def SYSTem_RAM(self, input = None): + self.pyvisa_instrument_object.write(f':SYSTem:RAM? {str(input)}') + def SYSTem_SETup(self, input = None): + self.pyvisa_instrument_object.write(f':SYSTem:SETup {str(input)}') + def TRACen(self, input = None): + self.pyvisa_instrument_object.write(f':TRACe[] {str(input)}') + def TRACen_DATA(self, input = None): + self.pyvisa_instrument_object.write(f':TRACe[]:DATA {str(input)}') + def TRACen_DATA_DAC16(self, input = None): + self.pyvisa_instrument_object.write(f':TRACe[]:DATA:DAC16 {str(input)}') + def TRACen_DATA_DAC(self, input = None): + self.pyvisa_instrument_object.write(f':TRACe[]:DATA:DAC {str(input)}') + def TRACen_DATA_POINts(self, input = None): + self.pyvisa_instrument_object.write(f':TRACe[]:DATA:POINts {str(input)}') + def TRACen_DATA_POINts_INTerpolate(self, input = None): + self.pyvisa_instrument_object.write(f':TRACe[]:DATA:POINts:INTerpolate {str(input)}') + def TRACen_DATA_VALue(self, input = None): + self.pyvisa_instrument_object.write(f':TRACe[]:DATA:VALue {str(input)}') + def TRACen_DATA_LOAD(self, input = None): + self.pyvisa_instrument_object.write(f':TRACe[]:DATA:LOAD? {str(input)}') + def TIMebase_DELay_ENABle(self, input = None): + self.pyvisa_instrument_object.write(f':TIMebase:DELay:ENABle {str(input)}') + def TIMebase_DELay_OFFSet(self, input = None): + self.pyvisa_instrument_object.write(f':TIMebase:DELay:OFFSet {str(input)}') + def TIMebase_DELay_SCALe(self, input = None): + self.pyvisa_instrument_object.write(f':TIMebase:DELay:SCALe {str(input)}') + def TIMebase_MAIN_OFFSet(self, input = None): + self.pyvisa_instrument_object.write(f':TIMebase[:MAIN]:OFFSet {str(input)}') + def TIMebase_MAIN_SCALe(self, input = None): + self.pyvisa_instrument_object.write(f':TIMebase[:MAIN]:SCALe {str(input)}') + def TIMebase_MODE(self, input = None): + self.pyvisa_instrument_object.write(f':TIMebase:MODE {str(input)}') + def TRIGger_MODE(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:MODE {str(input)}') + def TRIGger_COUPling(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:COUPling {str(input)}') + def TRIGger_SWEep(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:SWEep {str(input)}') + def TRIGger_HOLDoff(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:HOLDoff {str(input)}') + def TRIGger_NREJect(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:NREJect {str(input)}') + def TRIGger_EDGe(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:EDGe {str(input)}') + def TRIGger_PULSe(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:PULSe {str(input)}') + def TRIGger_SLOPe(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:SLOPe {str(input)}') + def TRIGger_VIDeo(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:VIDeo {str(input)}') + def TRIGger_PATTern(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:PATTern {str(input)}') + def TRIGger_DURATion(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:DURATion {str(input)}') + def TRIGger_TIMeout(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:TIMeout {str(input)}') + def TRIGger_RUNT(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:RUNT {str(input)}') + def TRIGger_WINDows(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:WINDows {str(input)}') + def TRIGger_DELay(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:DELay {str(input)}') + def TRIGger_SHOLd(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:SHOLd {str(input)}') + def TRIGger_NEDGe(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:NEDGe {str(input)}') + def TRIGger_NEDGe_SLOPe(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:NEDGe:SLOPe {str(input)}') + def TRIGger_NEDGe_EDGE(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:NEDGe:EDGE {str(input)}') + def TRIGger_NEDGe_LEVel(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:NEDGe:LEVel {str(input)}') + def TRIGger_RS232(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:RS232 {str(input)}') + def TRIGger_IIC(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:IIC {str(input)}') + def TRIGger_SPI(self, input = None): + self.pyvisa_instrument_object.write(f':TRIGger:SPI {str(input)}') + def WAVeform_STARt(self, input = None): + self.pyvisa_instrument_object.write(f':WAVeform:STARt {str(input)}') + def WAVeform_STOP(self, input = None): + self.pyvisa_instrument_object.write(f':WAVeform:STOP {str(input)}') + def WAVeform_SOURce(self, input = None): + self.pyvisa_instrument_object.write(f':WAVeform:SOURce {str(input)}') + def WAVeform_MODE(self, input = None): + self.pyvisa_instrument_object.write(f':WAVeform:MODE {str(input)}') + def WAVeform_FORMat(self, input = None): + self.pyvisa_instrument_object.write(f':WAVeform:FORMat {str(input)}') + def LAN_STATus(self): + self.pyvisa_instrument_object.write(f':LAN:STATus? {str(input)}') + return self.pyvisa_instrument_object.read() + def LAN_VISA(self): + self.pyvisa_instrument_object.write(f':LAN:VISA? {str(input)}') + return self.pyvisa_instrument_object.read() + def WAVeform_DATA(self): + self.pyvisa_instrument_object.write(f':WAVeform:DATA? {str(input)}') + return self.pyvisa_instrument_object.read() + def WAVeform_XINCrement(self): + self.pyvisa_instrument_object.write(f':WAVeform:XINCrement? {str(input)}') + return self.pyvisa_instrument_object.read() + def WAVeform_XORigin(self): + self.pyvisa_instrument_object.write(f':WAVeform:XORigin? {str(input)}') + return self.pyvisa_instrument_object.read() + def WAVeform_XREFerence(self): + self.pyvisa_instrument_object.write(f':WAVeform:XREFerence? {str(input)}') + return self.pyvisa_instrument_object.read() + def WAVeform_YINCrement(self): + self.pyvisa_instrument_object.write(f':WAVeform:YINCrement? {str(input)}') + return self.pyvisa_instrument_object.read() + def WAVeform_YORigin(self): + self.pyvisa_instrument_object.write(f':WAVeform:YORigin? {str(input)}') + return self.pyvisa_instrument_object.read() + def WAVeform_YREFerence(self): + self.pyvisa_instrument_object.write(f':WAVeform:YREFerence? {str(input)}') + return self.pyvisa_instrument_object.read() + def WAVeform_PREamble(self): + self.pyvisa_instrument_object.write(f':WAVeform:PREamble? {str(input)}') + return self.pyvisa_instrument_object.read() + def TRIGger_POSition(self): + self.pyvisa_instrument_object.write(f':TRIGger:POSition? {str(input)}') + return self.pyvisa_instrument_object.read() + def SYSTem_ERRor_NEXT(self): + self.pyvisa_instrument_object.write(f':SYSTem:ERRor[:NEXT]? {str(input)}') + return self.pyvisa_instrument_object.read() + def _SOURcen_APPLy(self): + self.pyvisa_instrument_object.write(f'[:SOURce[]]:APPLy? {str(input)}') + return self.pyvisa_instrument_object.read() + def FUNCtion_WRECord_FMAX(self): + self.pyvisa_instrument_object.write(f':FUNCtion:WRECord:FMAX? {str(input)}') + return self.pyvisa_instrument_object.read() + def ESR(self): + self.pyvisa_instrument_object.write(f'*ESR? {str(input)}') + return self.pyvisa_instrument_object.read() + def IDN(self): + self.pyvisa_instrument_object.write(f'*IDN? {str(input)}') + return self.pyvisa_instrument_object.read() + def STB(self): + self.pyvisa_instrument_object.write(f'*STB? {str(input)}') + return self.pyvisa_instrument_object.read() + def TST(self): + self.pyvisa_instrument_object.write(f'*TST? {str(input)}') + return self.pyvisa_instrument_object.read() + def LAN_MAC(self): + self.pyvisa_instrument_object.write(f':LAN:MAC? {str(input)}') + return self.pyvisa_instrument_object.read() + def MASK_PASSed(self): + self.pyvisa_instrument_object.write(f':MASK:PASSed? {str(input)}') + return self.pyvisa_instrument_object.read() + def MASK_FAILed(self): + self.pyvisa_instrument_object.write(f':MASK:FAILed? {str(input)}') + return self.pyvisa_instrument_object.read() + def MASK_TOTal(self): + self.pyvisa_instrument_object.write(f':MASK:TOTal? {str(input)}') + return self.pyvisa_instrument_object.read() + def MEASure_COUNter_VALue(self): + self.pyvisa_instrument_object.write(f':MEASure:COUNter:VALue? {str(input)}') + return self.pyvisa_instrument_object.read() + def ACQuire_SRATe(self): + self.pyvisa_instrument_object.write(f':ACQuire:SRATe? {str(input)}') + return self.pyvisa_instrument_object.read() + def ETABlen_DATA(self): + self.pyvisa_instrument_object.write(f':ETABle:DATA? {str(input)}') + return self.pyvisa_instrument_object.read() + def DISPlay_DATA(self): + self.pyvisa_instrument_object.write(f':DISPlay:DATA? {str(input)}') + return self.pyvisa_instrument_object.read() + def DECodern_CONFig_SRATe(self): + self.pyvisa_instrument_object.write(f':DECoder:CONFig:SRATe? {str(input)}') + return self.pyvisa_instrument_object.read() diff --git a/equipment/oscilloscope/py_generated/__pycache__/DS1054Z.cpython-312.pyc b/equipment/oscilloscope/py_generated/__pycache__/DS1054Z.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..45170c945114e82d7094f792d1750c9bd30d7c33 GIT binary patch literal 61035 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 literal 0 HcmV?d00001 diff --git a/generator.py b/generator.py new file mode 100644 index 0000000..6abf61f --- /dev/null +++ b/generator.py @@ -0,0 +1,88 @@ +import os +import re + +functionBuffer = [] +writeBuffer = [] +with open(f'equipment/multimeter/md_sourcefiles/3458A.md') as file: + current_block = '' + command_block = '' + for line in file: + line = line.lstrip(' ') + line = line.replace('\n', '') + # check if descriptor block + try: + sub_block = line.split(' ', 1)[0] + if sub_block == '#': + command_block = line.split(' ', 1)[1] + writeBuffer.append(line) + if 'LIBRARY COMMANDS' in command_block: + current_block = 'FUNCTION' + if 'SETTEABLE PARAMETERS' in command_block: + current_block = 'SETTER' + if 'GETTEABLE PARAMETERS' in command_block: + current_block = 'GETTER' + if 'GETSETTEABLE PARAMETERS' in command_block: + current_block = 'GETSETTER' + # if sub_block a getter/setter make it + if sub_block == '-': + functionBuffer.append({"NAME":line.split(' ', 1)[1],"TYPE":current_block}) + # if sub_block make a function/parameter + if sub_block == '1.': + functionBuffer[-1].update({"DESCRIPTION":line.split(' ', 1)[1]}) + if sub_block == '2.': + functionBuffer[-1].update({"DEVICE_COMMAND":line.split(' ', 1)[1]}) + if sub_block == '3.': + functionBuffer[-1].update({"FUNCTION_CALL":line.split(' ', 1)[1]}) + except: + pass + +writeBuffer = '' +for functionality in functionBuffer: + tmpFunc = '' + # check what kind of function is needed + print(functionality) + try: + tmp = functionality["NAME"] + tmp_cmd_name = tmp.lstrip(':') + tmp_cmd_name = tmp_cmd_name.replace(':', '_') + tmp_cmd_name = re.sub(r'[^a-zA-Z0-9_]', '', tmp_cmd_name) + if functionality["TYPE"] == "FUNCTION": + tmpFunc += (f'\tdef out = {tmp_cmd_name}:\n') + if functionality["TYPE"] == "SETTER": + tmpFunc += (f'\tdef {tmp_cmd_name}(self, input = None):\n') + if functionality["TYPE"] == "GETTER": + tmpFunc += (f'\tdef {tmp_cmd_name}(self):\n') + if functionality["TYPE"] == "GETSETTER": + tmpFunc += (f'\tdef {tmp_cmd_name}(self, input = None):\n') + # add description + if "DESCRIPTION" in functionality: + tmp = functionality["DESCRIPTION"] + tmpFunc += (f'\t\t\'\'\'{tmp}\'\'\'\n') + # add command if not function + if not "DEVICE_COMMAND" in functionality: + tmp = functionality["NAME"] + tmpFunc += (f'\t\tself.pyvisa_instrument_object.write(f\'{tmp} ' + '{str(input)}\')\n') + else: + tmp = functionality["DEVICE_COMMAND"] + tmpFunc += (f'\t\t{tmp}\n') + # add return to getters + if functionality["TYPE"] == "GETTER": + tmpFunc += (f'\t\treturn self.pyvisa_instrument_object.read()\n') + if functionality["TYPE"] == "GETSETTER": + tmpFunc += (f'\t\treturn self.pyvisa_instrument_object.read()\n') + writeBuffer += (tmpFunc+'\n') + except: + pass +with open("demofile.py", "a") as f: + # add base constructor stuff + f.write('import pyvisa\n\n') + f.write('class DS1054Z(object):\n') + f.write('\tdef __init__(self, pyvisa_instrument_address, device_handle):\n') + f.write('\t\t# initiate correct device class and pass pyvisa handle\n') + f.write('\t\tself.pyvisa_instrument_address = pyvisa_instrument_address\n') + f.write('\t\tself.pyvisa_instrument_manager = pyvisa.ResourceManager()\n') + f.write('\t\tself.pyvisa_instrument_object = self.pyvisa_instrument_manager.open_resource(pyvisa_instrument_address)\n') + f.write('\t\tself.pyvisa_instrument_object = self.pyvisa_instrument_object\n') + f.write('\t\tself.device_handle = device_handle\n') + f.write('\t\tprint(f"[MeasKit] started control class instance for {device_handle} at {pyvisa_instrument_address}.")\n') + f.write(writeBuffer) diff --git a/supported_devices.json b/supported_devices.json new file mode 100644 index 0000000..1ea0722 --- /dev/null +++ b/supported_devices.json @@ -0,0 +1,7 @@ +{ + "supported_instruments": [ + { "make": "TEMPLATE", "type": "TEMPLATE" , "source": "TEMPLATE.py" }, + { "make": "3458A" , "type": "multimeter", "source": "3458A.py" }, + { "make": "DS1054Z" , "type": "oscilloscope", "source": "DS1054Z.py" } + ] +}