mpylab 0.9__py3-none-any.whl

mpylab/LICENSE

@@ -0,0 +1,25 @@
+This module is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This module is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this module.  If not, see <http://www.gnu.org/licenses/>.
+
+Dieses Modul ist Freie Software: Sie können es unter den Bedingungen
+der GNU General Public License, wie von der Free Software Foundation,
+Version 3 der Lizenz oder (nach Ihrer Wahl) jeder neueren
+veröffentlichten Version, weiter verteilen und/oder modifizieren.
+
+Dieses Modul wird in der Hoffnung bereitgestellt, dass es nützlich sein wird, jedoch
+OHNE JEDE GEWÄHR,; sogar ohne die implizite
+Gewähr der MARKTFÄHIGKEIT oder EIGNUNG FÜR EINEN BESTIMMTEN ZWECK.
+Siehe die GNU General Public License für weitere Einzelheiten.
+
+Sie sollten eine Kopie der GNU General Public License zusammen mit diesem
+Modul erhalten haben. Wenn nicht, siehe <https://www.gnu.org/licenses/>.

mpylab/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.9"

mpylab/device/Meta_ui.py

@@ -0,0 +1,304 @@
+# -*- coding: utf-8 -*-
+"""This is :mod:`mpylab.device.Metaui`: Metaclass to Build a standard GUI from the _setgetlist.
+
+   :author: Christian Albrecht, Hans Georg Krauthaeuser
+   :copyright: All rights reserved
+   :license: no licence yet
+"""
+
+import traits.api as tapi
+from traits.etsconfig.api import ETSConfig
+from traits.has_traits import MetaHasTraits
+
+ETSConfig.toolkit = "wx"
+import traitsui.api as tuiapi
+import traitsui.menu as tuim
+import io
+import re
+import inspect
+
+
+def erzeugeFired_Methode_mit_Rfunction(command, rfunction, param_list):
+    """
+    Functionfactory zum erzeugen von Traits-fired Funktionen.
+    """
+
+    def Methode_fired(self):
+        setattr(self, rfunction.upper(), str(eval('self.dv.%s(%s)' % (command, ", ".join(param_list)))[1]))
+
+    return Methode_fired
+
+
+def erzeugeFired_Methode(name, param_list):
+    """
+    Functionfactory zum erzeugen von Traits-fired Funktionen.
+    """
+
+    def Methode_fired(self):
+        setattr(self, name.upper(), str(eval('self.dv.%s(%s)' % (name, ", ".join(param_list)))[1]))
+
+    return Methode_fired
+
+
+def _Init_fired(self):
+    """
+    Standard init_fired Funktion.
+    """
+    ini = io.StringIO(self.INI)
+    self.dv.Init(ini)
+
+    # Alle Get Funktionen einmal aufrufen und so die Anzeige mit aktuellen Werten belegen.
+    for item in self.mainEntries:
+        m = re.match(r'^[Gg]et.*$', item)
+        if m:
+            getattr(self, "_%s_fired" % item)()
+
+
+def Erzeuge_TapiVar(typ):
+    """
+    Hilfsfunktion zum erstellen von Traits-Variablen.
+    """
+    if typ == float:
+        return tapi.Float()
+    elif typ == int:
+        return tapi.Int()
+    else:
+        return tapi.Str()
+
+
+class Metaui(MetaHasTraits):
+    """
+    Diese Metaklasse ermöglicht das einfache Erstellen von Guis für das Testen eines Drivers.
+    
+    Sie baut für alle im _commands- und _cmds-Dict vorhanden Commands und Functions passende Buttons und
+    Eingabefelder und nimmt so einem viel Schreibarbeit ab.
+    
+    Es werden für alles in _commands und _cmds definiert Kommandos Buttons und Felder erstellt. Sind in dem cmds-Dict mehr
+    Kommandos definiert als in _commands, so werden auch für diese Buttons gebaut. Der Grund für dieses Vorgehen liegt in der
+    Tatsache, dass diese GUI zum testen der Klasse gedacht ist und somit alle definierten Kommandso abgebildet werden sollen.
+    Sind in _commands Kommandos aufgeführt die nicht in der konkreten Dirver-Klasse vorhanden sind, so wird eine Methode
+    erstellt welche einen NotImplementedError wirft.
+    
+    
+    
+    Zu jeder Driver-Superklasse sollte ein UI-Superklasse existieren in der zusätzliche Taps definiert werden
+    die für alle von ihr abgeleiteten Driverklassen gleich sein sollen.
+    Damit die Metaklasse einwandfrei arbeiten kann, dürfen in der Superklasse nur 
+    sogenannte tuiapi.Group (das sind Taps) erstellt werden. Diese müssen wiederrum in einem Dict
+    mit dem Namen "GROUPS" gespeichert werden. Wobei folgende Konvention einzuhalten ist::
+    
+        GROUPS={'Name des Taps' : tuiapi.Group(...)}
+    
+    Als Beispiele siehe: :mod:`mpylab.device.networkanalyer_ui`
+    
+    
+    
+    Weiterhin muss eine UI-Klasse für jede konkrete Driver-Implementierung erstellt werden, diese muss von
+    der UI-Superklasse abgeleitet sein. In dieser muss die Meta_ui als Metaklasse angegeben werden, weiterhin 
+    sind folgende speziall Variablen nötig:
+    
+    **__driverclass__= :** Verweis auf eine konkrete Klasse einer Driver-Implementierung. ACHTUNG!! nur ein Verweis auf die Klasse, 
+                        keine Instanz der Klasse. 
+    
+    **__super_driverclass__=**: Verweis auf die Superklasse eines Driver. ACHTUNG!! nur ein Verweis auf die Klasse, 
+                            keine Instanz der Klasse.
+                            
+    Aus diesen Varialben holt sich die Metaklase das _commands-Dict und _cmds-Dict.
+    
+    Als Beispiel siehe: :class:`mpylab.device.nw_rs_zlv.UI`
+    
+    .. rubric:: Methods:
+    """
+
+    # def __init__(cls, eins, zwei, drei):
+    #    print "init %s \n\n   %s  \n\n %s"%(eins,zwei,drei)
+
+    def __new__(cls, class_name, bases, class_dict):
+
+        class_dict.update({'_Init_fired': _Init_fired})
+
+        driverclass = class_dict.get("__driverclass__")
+        super_driverclass = class_dict.get('__super_driverclass__')
+
+        tabs = 'INI_grp'
+        INI_grp = tuiapi.Group(
+            tuiapi.Item('INI', style='custom', springy=True, width=500, height=200, show_label=False),
+            tuiapi.Item('Init', show_label=False),
+            label='Ini')
+
+        # ********************
+        # _cmds abarbeiten
+        # ********************
+
+        _cmds = driverclass._cmds
+        mainEntries = []
+        items_Map = {}
+
+        for command_name, command in list(_cmds.items()):
+            items = ""
+            if command_name in class_dict['_ignore']:
+                continue
+            if command_name in mainEntries:
+                continue
+
+            mainEntries.append(command_name)
+
+            items = "%s tuiapi.Group(" % (items)
+            items = "%s tuiapi.Item('%s',show_label=False,width=100)," % (items, command_name)
+            class_dict[command_name] = tapi.Button(command_name)
+
+            if command.Rfunction():
+                items = "%s tuiapi.Item('%s',show_label=False,width=100)," % (items, command.Rfunction())
+                items = "%s tuiapi.Item('%s',label='Wert',style='readonly',width=70)," % (
+                    items, command.Rfunction().upper())
+
+                class_dict[command.Rfunction().upper()] = Erzeuge_TapiVar(str)
+                class_dict[command.Rfunction()] = tapi.Button(command.Rfunction())
+
+                if command.Rfunction() not in mainEntries:
+                    mainEntries.append(command.Rfunction())
+
+                if command.Rfunction() in list(items_Map.keys()):
+                    del items_Map[command.Rfunction()]
+            else:
+                items = "%s tuiapi.Item('%s',label='%s',style='readonly',width=70)," % (
+                    items, command_name.upper(), 'Wert'.rjust(38))
+                class_dict[command_name.upper()] = Erzeuge_TapiVar(str)
+
+            param_list = []
+            for param_name in command.getParameterTuple():
+                param = command.getParameter()[param_name]
+                if param.isClass_attr():
+                    continue
+
+                if hasattr(driverclass, command_name):
+                    if param_name not in inspect.getfullargspec(getattr(driverclass, command_name))[0]:
+                        continue
+
+                items = "%s tuiapi.Item('param_%s_%s',label='%s',width=60)," % (items,
+                                                                                command_name,
+                                                                                param_name.upper(),
+                                                                                param_name)
+                class_dict['param_%s_%s' % (command_name, param_name.upper())] = Erzeuge_TapiVar(param.Getptype())
+                param_list.append('self.param_%s_%s' % (command_name, param_name.upper()))
+
+            if command.Rfunction():
+                class_dict["_%s_fired" % command_name] = erzeugeFired_Methode_mit_Rfunction(command_name,
+                                                                                            command.Rfunction(),
+                                                                                            param_list)
+                class_dict["_%s_fired" % command.Rfunction()] = erzeugeFired_Methode(command.Rfunction(), [])
+
+            else:
+                class_dict["_%s_fired" % command_name] = erzeugeFired_Methode(command_name, param_list)
+
+            items = "%s orientation='horizontal')" % (items)
+            items_Map[command_name] = items
+
+        class_dict.update({'mainEntries': mainEntries})
+
+        item_List = list(items_Map.values())
+        item_List = [item_List[i:i + 16] for i in range(0, len(item_List), 16)]
+
+        tabs_list_index = 0
+        tabs_list = []
+
+        for item in item_List:
+            tabs_list.append(tuiapi.Group(eval(", ".join(item)), label='Main_%d' % tabs_list_index))
+            tabs = tabs + ", tabs_list[%d]" % tabs_list_index
+            tabs_list_index = tabs_list_index + 1
+
+        # *******************
+        # commands abarbeiten
+        # *******************
+
+        notIEntries = []
+        items_Map = {}
+
+        for command_name, item in list(super_driverclass._commands.items()):
+            items = ""
+            if (command_name in mainEntries) or (command_name in notIEntries):
+                continue
+            if command_name in class_dict['_ignore']:
+                continue
+
+            if item['parameter']:
+                para_command = item['parameter']
+                if isinstance(para_command, str):
+                    para_command = (para_command,)
+
+            # Testen ob die Methode direkt, also nicht über _cmds, implementiert wurde:
+            # Wird die Methode in _commands angegeben, aber nicht implementiert wurde,
+            # Erzeug die Meta Klasse eine Methode die einen  NotImplementedError wirft
+            driver_ins = driverclass()
+            try:
+                p = ""
+                if item['parameter']:
+                    for param_name in para_command:
+                        p = p + "'',"
+                eval('driverclass.%s(driver_ins,%s)' % (command_name, p))
+            except NotImplementedError:
+                pass
+            else:
+                driver_ins.__del__()
+                continue
+
+            driver_ins.__del__()
+
+            notIEntries.append(command_name)
+
+            items = "%s tuiapi.Group(" % (items)
+            items = "%s tuiapi.Item('%s',show_label=False,width=100)," % (items, command_name)
+            class_dict[command_name] = tapi.Button(command_name)
+
+            items = "%s tuiapi.Item('%s',label='%s',style='readonly',width=70)," % (items, command_name.upper(), 'Wert')
+            class_dict[command_name.upper()] = Erzeuge_TapiVar(str)
+
+            param_list = []
+
+            if item['parameter']:
+                for param_name in para_command:
+                    items = "%s tuiapi.Item('param_%s_%s',label='%s',width=60)," % (
+                        items, command_name, param_name.upper(), param_name)
+                    class_dict['param_%s_%s' % (command_name, param_name.upper())] = Erzeuge_TapiVar(str)
+                    param_list.append('self.param_%s_%s' % (command_name, param_name.upper()))
+
+            class_dict["_%s_fired" % command_name] = erzeugeFired_Methode(command_name, param_list)
+
+            items = "%s orientation='horizontal')" % (items)
+            items_Map[command_name] = items
+
+        item_List = list(items_Map.values())
+        item_List = [item_List[i:i + 16] for i in range(0, len(item_List), 16)]
+
+        for item in item_List:
+            tabs_list.append(tuiapi.Group(eval(", ".join(item)), label='NotImp_%d' % tabs_list_index))
+            tabs = tabs + ", tabs_list[%d]" % tabs_list_index
+            tabs_list_index = tabs_list_index + 1
+
+        # **********************
+        # In den UI Klassen definiert Groups holen:
+        # ************************
+
+        for i in class_dict:
+            if type(class_dict.get(i)) == tuiapi.Group:
+                tabs = '%s,class_dict.get("%s")' % (tabs, i)
+
+        i = 0
+        for b in bases:
+            for n, v in list(b.GROUPS.items()):
+                if type(v) == tuiapi.Group:
+                    tabs = '%s,bases[%d].GROUPS["%s"]' % (tabs, i, n)
+            i = i + 1
+
+        # *************
+        # Fenster zusammen bauen:
+        # ***************
+
+        tabs = "tuiapi.Group(%s, layout='tabbed')" % tabs
+
+        class_dict.update(
+            {'traits_view': tuiapi.View(eval(tabs), title="Spectrumanalyer", buttons=[tuim.CancelButton])})
+
+        # print "Meta   %s \n\n bases\n %s \n\n dict \n %s"%(class_name,str(bases),str(class_dict))
+
+        return MetaHasTraits.__new__(cls, class_name, bases, class_dict)

mpylab/device/__init__.py

@@ -0,0 +1 @@
+

mpylab/device/amp_ar_25s1g4.py

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+from simpleeval import simple_eval
+
+from mpylab.device.amplifier import AMPLIFIER as AMP
+
+
+class AMPLIFIER(AMP):
+    conftmpl = AMP.conftmpl
+    conftmpl['init_value']['gpib'] = int
+
+    def __init__(self):
+        AMP.__init__(self)
+        self._cmds = {'POn': [("P1", None)],
+                      'POff': [("P0", None)],
+                      'Operate': [("G4095", None)],
+                      'Standby': [("G0000", None)],
+                      'GetDescription': [('*IDN?', r'(?P<IDN>.*)')]}
+        self.term_chars = '\r\n'
+        self.error = None
+
+    def Init(self, ini=None, channel=None):
+        self.error = AMP.Init(self, ini, channel)
+        self.POn()
+        self.Operate()
+        return self.error
+
+
+def main():
+    import sys
+    import io
+
+    from mpylab.tools.util import format_block
+    import scuq
+
+    try:
+        ini = sys.argv[1]
+    except IndexError:
+        ini = format_block("""
+                         [description]
+                         DESCRIPTION = 25s1g4
+                         TYPE = AMPLIFIER
+                         VENDOR = AR
+                         SERIALNR = 
+                         DEVICEID = 
+                         DRIVER =
+
+                         [INIT_VALUE]
+                         FSTART = 800e6
+                         FSTOP = 4.2e9
+                         FSTEP = 0.0
+                         NR_OF_CHANNELS = 2
+                         GPIB = 1
+                         VIRTUAL = 0
+
+                         [CHANNEL_1]
+                         NAME = S21
+                         UNIT = dB
+                         INTERPOLATION = LOG
+                         FILE = io.StringIO(format_block('''
+                                                                FUNIT: Hz
+                                                                UNIT: dB
+                                                                ABSERROR: 0.0
+                                                                800e6 45
+                                                                4.2e9 45
+                                                                '''))
+                         [CHANNEL_2]
+                         NAME = MAXIN
+                         UNIT = dBm
+                         INTERPOLATION = LOG
+                         FILE = io.StringIO(format_block('''
+                                                                FUNIT: Hz
+                                                                UNIT: dBm
+                                                                ABSERROR: 0.0
+                                                                800e6 0
+                                                                4.2e9 0
+                                                                '''))
+                         """)
+        ini = io.StringIO(ini)
+
+    amp = AMPLIFIER()
+    err = amp.Init(ini)
+    print(amp.GetDescription())
+    ctx = scuq.ucomponents.Context()
+    while True:
+        freq = float(simple_eval(input("Freq / Hz: ")))
+        if freq < 0:
+            break
+        amp.SetFreq(freq)
+        err, uq = amp.GetData(what='S21')
+        val, unc, unit = ctx.value_uncertainty_unit(uq)
+        print((freq, uq, val, unc, unit))
+    err = amp.Quit()
+
+
+if __name__ == '__main__':
+    main()

mpylab/device/amp_blma_1018_100.py

@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+import pyvisa
+import time
+from mpylab.device.amplifier import AMPLIFIER as AMP
+
+
+class AMPLIFIER(AMP):
+    conftmpl = AMP.conftmpl
+    conftmpl['init_value']['gpib'] = int
+
+    def __init__(self):
+        AMP.__init__(self)
+        self.operating = False
+        self._cmds = {'POn': [("AMP_OFF", None)],
+                      'POff': [("AMP_OFF", None)],
+                      'Operate': [("AMP_ON", None)],
+                      'Standby': [("AMP_OFF", None)],
+                      'GetDescription': [('*IDN?', r'(?P<IDN>.*)')]}
+        self.term_chars = '\n'
+        self.error = None
+
+    def Init(self, ini=None, channel=None):
+        self.error = AMP.Init(self, ini, channel)
+        # self.POn()
+        self.Standby()
+        # time.sleep(2)
+        return self.error
+
+    def _query(self, cmd, N=5, sleep=0.2):
+        ans = None
+        for _ in range(N):
+            try:
+                ans = self.dev.query(cmd)
+                break  # no exception
+            except pyvisa.VisaIOError:
+                time.sleep(sleep)
+                continue  # try again
+        else:
+            raise  # re raise exception
+        return ans
+
+    def _wait(self, state=False):
+        while True:
+            ans = self._query('AMP?')
+            rstate = (ans == 'AMP_ON')
+            if state == rstate:
+                break
+            time.sleep(0.1)
+
+    def SetFreq(self, freq):
+        self.error = 0
+        if (1e9 <= freq <= 18e9) and (not self.operating):
+            self.Operate()
+            time.sleep(2)
+            self.operating = True
+        elif (not 1e9 <= freq <= 18e9) and self.operating:
+            self.Standby()
+            self.operating = False
+            return self.error, freq
+
+        swstat = self._query('SW01?')
+        assert swstat.startswith('SW01_')
+        swstat = int(swstat[-1])
+        if freq <= 2e9:
+            sw = 1
+        elif freq <= 6e9:
+            sw = 2
+        else:
+            sw = 3
+
+        if sw != swstat:
+            self.Standby()
+            self._wait(False)
+            self.write('SW01_%d' % sw)
+            self.Operate()
+            self._wait(True)
+            time.sleep(2)
+        self.error, freq = AMP.SetFreq(self, freq)
+        time.sleep(0.2)
+        return self.error, freq
+
+
+def main():
+    import sys
+    import io
+
+    from mpylab.tools.util import format_block
+    import scuq
+
+    try:
+        ini = sys.argv[1]
+    except IndexError:
+        ini = format_block("""
+                         [description]
+                         DESCRIPTION = BLMA1018 100
+                         TYPE = AMPLIFIER
+                         VENDOR = Bonn
+                         SERIALNR = 
+                         DEVICEID = 
+                         DRIVER =
+
+                         [INIT_VALUE]
+                         FSTART = 1e9
+                         FSTOP = 18e9
+                         FSTEP = 0.0
+                         NR_OF_CHANNELS = 2
+                         GPIB = 7
+                         VIRTUAL = 0
+
+                         [CHANNEL_1]
+                         NAME = S21
+                         UNIT = dB
+                         INTERPOLATION = LOG
+                         FILE = io.StringIO(format_block('''
+                                                                FUNIT: Hz
+                                                                UNIT: dB
+                                                                ABSERROR: 0.5
+                                                                1e9 50
+                                                                2e9 50
+                                                                2.001e0 44.8
+                                                                6e9 44.8
+                                                                6.001e9 43
+                                                                18e9 43
+                                                                '''))
+                         [CHANNEL_2]
+                         NAME = MAXIN
+                         UNIT = dBm
+                         INTERPOLATION = LOG
+                         FILE = io.StringIO(format_block('''
+                                                                FUNIT: Hz
+                                                                UNIT: dBm
+                                                                ABSERROR: 0.0
+                                                                1e9 -5
+                                                                18e9 -5
+                                                                '''))
+                         """)
+        ini = io.StringIO(ini)
+
+    amp = AMPLIFIER()
+    err = amp.Init(ini)
+    ctx = scuq.ucomponents.Context()
+    while True:
+        freq = float(eval(input("Freq / Hz: ")))
+        if freq < 0:
+            break
+        amp.SetFreq(freq)
+        err, uq = amp.GetData(what='S21')
+        val, unc, unit = ctx.value_uncertainty_unit(uq)
+        print((freq, uq, val, unc, unit))
+    amp.POff()
+
+
+if __name__ == '__main__':
+    main()

mpylab/device/amp_blwa_0810_100.py

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+import time
+
+from mpylab.device.amplifier import AMPLIFIER as AMP
+
+
+class AMPLIFIER(AMP):
+    conftmpl = AMP.conftmpl
+    conftmpl['init_value']['gpib'] = int
+
+    def __init__(self):
+        AMP.__init__(self)
+        self.operating = False
+        self._cmds = {'POn': [("AMP_OFF", None)],
+                      'POff': [("AMP_OFF", None)],
+                      'Operate': [("AMP_ON", None)],
+                      'Standby': [("AMP_OFF", None)],
+                      'GetDescription': [('*IDN?', r'(?P<IDN>.*)')]}
+        self.term_chars = '\n'
+
+    def Init(self, ini=None, channel=None):
+        self.error = AMP.Init(self, ini, channel)
+        # self.POn()
+        self.Standby()
+        # time.sleep(2)
+        return self.error
+
+    def SetFreq(self, freq):
+        self.error = 0
+
+        if (80e6 <= freq <= 1e9) and (not self.operating):
+            self.Operate()
+            time.sleep(2)
+            self.operating = True
+        elif (not 80e6 <= freq <= 1e9) and self.operating:
+            self.Standby()
+            self.operating = False
+            return self.error, freq
+
+        self.error, freq = AMP.SetFreq(self, freq)
+        time.sleep(0.2)
+        return self.error, freq
+
+
+def main():
+    import sys
+    import io
+
+    from mpylab.tools.util import format_block
+    import scuq
+
+    try:
+        ini = sys.argv[1]
+    except IndexError:
+        ini = format_block("""
+                         [description]
+                         DESCRIPTION = BLMA0810 100
+                         TYPE = AMPLIFIER
+                         VENDOR = Bonn
+                         SERIALNR = 
+                         DEVICEID = 
+                         DRIVER =
+
+                         [INIT_VALUE]
+                         FSTART = 80e6
+                         FSTOP = 1e9
+                         FSTEP = 0.0
+                         NR_OF_CHANNELS = 2
+                         GPIB = 9
+                         VIRTUAL = 0
+
+                         [CHANNEL_1]
+                         NAME = S21
+                         UNIT = dB
+                         INTERPOLATION = LOG
+                         FILE = io.StringIO(format_block('''
+                                                                FUNIT: Hz
+                                                                UNIT: dB
+                                                                ABSERROR: 0.5
+                                                                80e6 50
+                                                                1e9 50
+                                                                '''))
+                         [CHANNEL_2]
+                         NAME = MAXIN
+                         UNIT = dBm
+                         INTERPOLATION = LOG
+                         FILE = io.StringIO(format_block('''
+                                                                FUNIT: Hz
+                                                                UNIT: dBm
+                                                                ABSERROR: 0.0
+                                                                80e6 -5
+                                                                1e9 -5
+                                                                '''))
+                         """)
+        ini = io.StringIO(ini)
+
+    amp = AMPLIFIER()
+    err = amp.Init(ini)
+    ctx = scuq.ucomponents.Context()
+    while True:
+        freq = float(eval(input("Freq / Hz: ")))
+        if freq < 0:
+            break
+        amp.SetFreq(freq)
+        err, uq = amp.GetData(what='S21')
+        val, unc, unit = ctx.value_uncertainty_unit(uq)
+        print((freq, uq, val, unc, unit))
+
+
+if __name__ == '__main__':
+    main()