New AMI430 driver

environment.yml

@@ -0,0 +1,20 @@
+name: qcodes
+channels: 
+ - defaults
+ - conda-forge
+dependencies:
+ - h5py=2.6.0
+ - matplotlib=2.0.2
+ - pyqtgraph 
+ - python=3.6
+ - jsonschema
+ - pyvisa
+ - QtPy=1.2.0
+ - sip
+ - pyqt=5.6.0
+ - numpy
+ - jupyter=1.0.0
+ - typing
+ - hypothesis
+ - pytest
+ - pytest-runner

qcodes/instrument/base.py

@@ -1,16 +1,17 @@
 """Instrument base class."""
 import logging
-import numpy as np
 import time
 import warnings
 import weakref
 from typing import Sequence
 
-from qcodes.utils.metadata import Metadatable
+import numpy as np
+
 from qcodes.utils.helpers import DelegateAttributes, strip_attrs, full_class
+from qcodes.utils.metadata import Metadatable
 from qcodes.utils.validators import Anything
-from .parameter import StandardParameter
 from .function import Function
+from .parameter import StandardParameter
 
 
 class InstrumentBase(Metadatable, DelegateAttributes):
@@ -38,13 +39,38 @@ class InstrumentBase(Metadatable, DelegateAttributes):
             such as channel lists or logical groupings of parameters.
             Usually populated via ``add_submodule``
     """
-    def __init__(self, name, **kwargs):
+
+    def __init__(self, name, testing=False, **kwargs):
         self.name = str(name)
+        self._testing = testing
+
+        if testing:
+            if hasattr(type(self), "mocker_class"):
+                mocker_class = type(self).mocker_class
+                self.mocker = mocker_class(name)
+            else:
+                raise ValueError("Testing turned on but no mocker class defined")
+
         self.parameters = {}
         self.functions = {}
         self.submodules = {}
         super().__init__(**kwargs)
 
+    def is_testing(self):
+        """Return True if we are testing"""
+        return self._testing
+
+    def get_mock_messages(self):
+        """
+        For testing purposes we might want to get log messages from the mocker.
+
+        Returns:
+            mocker_messages: list, str
+        """
+        if not self._testing:
+            raise ValueError("Cannot get mock messages if not in testing mode")
+        return self.mocker.get_log_messages()
+
     def add_parameter(self, name, parameter_class=StandardParameter,
                       **kwargs):
         """
@@ -150,12 +176,13 @@ def snapshot_base(self, update: bool=False,
         Returns:
             dict: base snapshot
         """
-        snap = {'functions': dict((name, func.snapshot(update=update))
-                                  for name, func in self.functions.items()),
-                'submodules': dict((name, subm.snapshot(update=update))
-                                   for name, subm in self.submodules.items()),
-                '__class__': full_class(self),
-                }
+
+        snap = {
+            "functions": {name: func.snapshot(update=update) for name, func in self.functions.items()},
+            "submodules": {name: subm.snapshot(update=update) for name, subm in self.submodules.items()},
+            "__class__": full_class(self)
+        }
+
         snap['parameters'] = {}
         for name, param in self.parameters.items():
             update = update
@@ -335,12 +362,12 @@ class Instrument(InstrumentBase):
 
     _all_instruments = {}
 
-    def __init__(self, name, **kwargs):
+    def __init__(self, name, testing=False, **kwargs):
         self._t0 = time.time()
         if kwargs.pop('server_name', False):
             warnings.warn("server_name argument not supported any more",
                           stacklevel=0)
-        super().__init__(name, **kwargs)
+        super().__init__(name, testing=testing, **kwargs)
 
         self.add_parameter('IDN', get_cmd=self.get_idn,
                            vals=Anything())
@@ -576,7 +603,10 @@ def write(self, cmd):
                 including the command and the instrument.
         """
         try:
-            self.write_raw(cmd)
+            if self._testing:
+                self.mocker.write(cmd)
+            else:
+                self.write_raw(cmd)
         except Exception as e:
             e.args = e.args + ('writing ' + repr(cmd) + ' to ' + repr(self),)
             raise e
@@ -615,7 +645,13 @@ def ask(self, cmd):
                 including the command and the instrument.
         """
         try:
-            return self.ask_raw(cmd)
+            if self._testing:
+                answer = self.mocker.ask(cmd)
+            else:
+                answer = self.ask_raw(cmd)
+
+            return answer
+
         except Exception as e:
             e.args = e.args + ('asking ' + repr(cmd) + ' to ' + repr(self),)
             raise e

qcodes/instrument/ip.py

@@ -36,9 +36,9 @@ class IPInstrument(Instrument):
     """
 
     def __init__(self, name, address=None, port=None, timeout=5,
-                 terminator='\n', persistent=True, write_confirmation=True,
+                 terminator='\n', persistent=True, write_confirmation=True, testing=False,
                  **kwargs):
-        super().__init__(name, **kwargs)
+        super().__init__(name, testing=testing, **kwargs)
 
         self._address = address
         self._port = port
@@ -88,7 +88,14 @@ def set_persistent(self, persistent):
         else:
             self._disconnect()
 
+    def flush_connection(self):
+        if not self._testing:
+            self._recv()
+
     def _connect(self):
+        if self._testing:
+            return
+
         if self._socket is not None:
             self._disconnect()
 

qcodes/instrument/mockers/ami430.py

@@ -0,0 +1,217 @@
+import re
+import time
+from datetime import datetime
+
+
+class MockAMI430:
+    states = {
+        "RAMPING to target field/current": "1",
+        "HOLDING at the target field/current": "2",
+        "PAUSED": "3",
+        "Ramping in MANUAL UP mode": "4",
+        "Ramping in MANUAL DOWN mode": "5",
+        "ZEROING CURRENT (in progress)": "6",
+        "Quench detected": "7",
+        "At ZERO current": "8",
+        "Heating persistent switch": "9",
+        "Cooling persistent switch": "10"
+    }
+
+    field_units = {
+        "tesla": "1",
+        "kilogauss": "0"
+    }
+
+    ramp_rate_units = {
+        "A/s": "0",
+        "A/min": "1"
+    }
+
+    quench_state = {False: "0", True: "1"}
+
+    def __init__(self, name):
+
+        self.name = name
+        self.log_messages = []
+
+        self._field_mag = 0
+        self._field_target = 0
+        self._state = MockAMI430.states["HOLDING at the target field/current"]
+
+        self.handlers = {
+            "RAMP:RATE:UNITS": {
+                "get": MockAMI430.ramp_rate_units["A/s"],
+                "set": None
+            },
+            "FIELD:UNITS": {
+                "get": MockAMI430.field_units["tesla"],
+                "set": None
+            },
+            "*IDN": {
+                "get": "v0.1 Mock",
+                "set": None
+            },
+            "STATE": {
+                "get": self._getter("_state"),
+                "set": self._setter("_state")
+            },
+            "FIELD:MAG": {
+                "get": self._getter("_field_mag"),
+                "set": None
+            },
+            "QU": {
+                "get": MockAMI430.quench_state[False],  # We are never in a quenching state so always return the
+                # same value
+                "set": None
+            },
+            "PERS": {
+                "get": "0",
+                "set": None
+            },
+            "PAUSE": {
+                "get": self._is_paused,
+                "set": self._do_pause
+            },
+            "CONF:FIELD:TARG": {
+                "get": None,  # To get the field target, send a message "FIELD:TARG?"
+                "set": self._setter("_field_target")
+            },
+            "FIELD:TARG": {
+                "get": self._getter("_field_target"),
+                "set": None
+            },
+            "PS": {
+                "get": "0",  # The heater is off
+                "set": None
+            },
+            "RAMP": {
+                "set": self._do_ramp,
+                "get": None
+            },
+            "RAMP:RATE:CURRENT": {
+                "get": "0.1000,50.0000",
+                "set": None
+            },
+            "COIL": {
+                "get": "1",
+                "set": None
+            }
+        }
+
+    @staticmethod
+    def message_parser(gs, msg_str, key):
+        """
+        * If gs = "get":
+        Let suppose key = "RAMP:RATE:UNITS", then if we get msg_str = "RAMP:RATE:UNITS?" then match will be True and
+        args = None. If msg_str = "RAMP:RATE:UNITS:10?" then match = True and args = "10". On the other hand if
+        key = "RAMP" then both "RAMP:RATE:UNITS?" and "RAMP:RATE:UNITS:10?" will cause match to be False
+
+        * If gs = "set"
+        If key = "STATE" and msg_str = "STATE 2,1" then match = True and args = "2,1". If key="STATE" and
+        msg_str =  STATE:ELSE 2,1 then match is False.
+
+        Consult [1] for a complete description of the AMI430 protocol.
+
+        [1] http://www.americanmagnetics.com/support/manuals/mn-4Q06125PS-430.pdf
+
+        Parameters:
+            gs (string):  "get", or "set"
+            msg_str (string): the message string the mock instrument gets.
+            key (string): one of the keys in self.handlers
+
+        Returns:
+            match (bool): if the key and the msg_str match, then match = True
+            args (string): if any arguments are present in the message string these will be passed along. This is
+                            always None when match = False
+
+        """
+        if msg_str == key:  # If the message string matches a key exactly we have a match with no arguments
+            return True, None
+
+        # We use regular expressions to find out if the message string and the key match. We need to replace reserved
+        # regular expression characters in the key. For instance replace "*IDN" with "\*IDN".
+        reserved_re_characters = "\^${}[]().*+?|<>-&"
+        for c in reserved_re_characters:
+            key = key.replace(c, "\{}".format(c))
+
+        s = {"get": "(:[^:]*)?\?$", "set": "([^:]+)"}[gs]  # Get and set messages use different regular expression
+        # patterns to determine a match
+        search_string = "^" + key + s
+        r = re.search(search_string, msg_str)
+        match = r is not None
+
+        args = None
+        if match:
+            args = r.groups()[0]
+            if args is not None:
+                args = args.strip(":")
+
+        return match, args
+
+    def _getter(self, attribute):
+        return lambda _: getattr(self, attribute)
+
+    def _setter(self, attribute):
+        return lambda value: setattr(self, attribute, value)
+
+    def _log(self, msg):
+
+        now = datetime.now()
+        log_line = "[{}] {}: {}".format(now.strftime("%d:%m:%Y-%H:%M:%S.%f"), self.name, msg)
+        self.log_messages.append(log_line)
+
+    def _handle_messages(self, msg):
+        """
+        Parameters:
+            msg (string): a message received through the socket communication layer
+
+        Returns:
+            rval (string or None): If the type of message requests a value (a get message) then this value is returned
+            by this function. A set message will return a None value.
+        """
+
+        gs = {True: "get", False: "set"}[msg.endswith("?")]  # A "get" message ends with a "?" and will invoke the get
+        # part of the handler defined in self.handlers.
+
+        rval = None
+        handler = None
+
+        for key in self.handlers:  # Find which handler is suitable to handle the message
+            match, args = MockAMI430.message_parser(gs, msg, key)
+            if not match:
+                continue
+
+            handler = self.handlers[key][gs]
+            if callable(handler):
+                rval = handler(args)
+            else:
+                rval = handler
+
+            break
+
+        if handler is None:
+            self._log("Command {} unknown".format(msg))
+
+        return rval
+
+    def _do_pause(self, _):
+        self._state = MockAMI430.states["PAUSED"]
+
+    def _is_paused(self):
+        return self._state == MockAMI430.states["PAUSED"]
+
+    def _do_ramp(self, _):
+        self._log("Ramping to {}".format(self._field_target))
+        self._state = MockAMI430.states["RAMPING to target field/current"]
+        time.sleep(0.1)  # Lets pretend to be ramping for a bit
+        self._field_mag = self._field_target
+        self._state = MockAMI430.states["HOLDING at the target field/current"]
+
+    def get_log_messages(self):
+        return self.log_messages
+
+    def ask(self, msg):
+        return self._handle_messages(msg)
+
+    def write(self, msg):
+        self._handle_messages(msg)