diff --git a/docs/examples/driver_examples/Qcodes example with Alazar 9360.ipynb b/docs/examples/driver_examples/Qcodes example with Alazar 9360.ipynb
new file mode 100644
index 000000000000..d0a023aae1d7
--- /dev/null
+++ b/docs/examples/driver_examples/Qcodes example with Alazar 9360.ipynb	
@@ -0,0 +1,1618 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Qcodes example with Alazar ATS 9360"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import all necessary things\n",
+    "%matplotlib nbagg\n",
+    "\n",
+    "import qcodes as qc\n",
+    "import qcodes.instrument.parameter as parameter\n",
+    "import qcodes.instrument_drivers.AlazarTech.ATS9360 as ATSdriver\n",
+    "import qcodes.instrument_drivers.AlazarTech.ATS_acquisition_controllers as ats_contr"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[{'bits_per_sample': 12,\n",
+       "  'board_id': 1,\n",
+       "  'board_kind': 'ATS9360',\n",
+       "  'max_samples': 4294967294,\n",
+       "  'system_id': 1}]"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Command to list all alazar boards connected to the system\n",
+    "ATSdriver.AlazarTech_ATS.find_boards()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'CPLD_version': '25.16',\n",
+       " 'SDK_version': '6.0.0',\n",
+       " 'asopc_type': '1779729248',\n",
+       " 'bits_per_sample': 12,\n",
+       " 'driver_version': '6.0.0',\n",
+       " 'firmware': None,\n",
+       " 'latest_cal_date': '25-01-17',\n",
+       " 'max_samples': 4294967294,\n",
+       " 'memory_size': '4294967294',\n",
+       " 'model': 'ATS9360',\n",
+       " 'pcie_link_speed': '0.5GB/s',\n",
+       " 'pcie_link_width': '8',\n",
+       " 'serial': '970396',\n",
+       " 'vendor': 'AlazarTech'}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Create the ATS9870 instrument on the new server \"alazar_server\"\n",
+    "ats_inst = ATSdriver.AlazarTech_ATS9360(name='Alazar1')\n",
+    "# Print all information about this Alazar card\n",
+    "ats_inst.get_idn()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Instantiate an acquisition controller (In this case we are doing a simple DFT) on the same server (\"alazar_server\") and \n",
+    "# provide the name of the name of the alazar card that this controller should control\n",
+    "acquisition_controller = ats_contr.Demodulation_AcquisitionController(name='acquisition_controller', \n",
+    "                                                                      demodulation_frequency=10e6, \n",
+    "                                                                      alazar_name='Alazar1')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configure all settings in the Alazar card\n",
+    "ats_inst.config(clock_source='INTERNAL_CLOCK',\n",
+    "              sample_rate=1_000_000_000,\n",
+    "              clock_edge='CLOCK_EDGE_RISING',\n",
+    "              decimation=1,\n",
+    "              coupling=['DC','DC'],\n",
+    "              channel_range=[.4,.4],\n",
+    "              impedance=[50,50],\n",
+    "              trigger_operation='TRIG_ENGINE_OP_J',\n",
+    "              trigger_engine1='TRIG_ENGINE_J',\n",
+    "              trigger_source1='EXTERNAL',\n",
+    "              trigger_slope1='TRIG_SLOPE_POSITIVE',\n",
+    "              trigger_level1=160,\n",
+    "              trigger_engine2='TRIG_ENGINE_K',\n",
+    "              trigger_source2='DISABLE',\n",
+    "              trigger_slope2='TRIG_SLOPE_POSITIVE',\n",
+    "              trigger_level2=128,\n",
+    "              external_trigger_coupling='DC',\n",
+    "              external_trigger_range='ETR_2V5',\n",
+    "              trigger_delay=0,\n",
+    "              timeout_ticks=0,\n",
+    "              aux_io_mode='AUX_IN_AUXILIARY', # AUX_IN_TRIGGER_ENABLE for seq mode on\n",
+    "              aux_io_param='NONE' # TRIG_SLOPE_POSITIVE for seq mode on\n",
+    "             )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "# This command is specific to this acquisition controller. The kwargs provided here are being forwarded to ats_inst.acquire\n",
+    "# This way, it becomes easy to change acquisition specific settings from the ipython notebook\n",
+    "acquisition_controller.update_acquisitionkwargs(#mode='NPT',\n",
+    "                 samples_per_record=1024,\n",
+    "                 records_per_buffer=70,\n",
+    "                 buffers_per_acquisition=1,\n",
+    "                 #channel_selection='AB',\n",
+    "                 #transfer_offset=0,\n",
+    "                 #external_startcapture='ENABLED',\n",
+    "                 #enable_record_headers='DISABLED',\n",
+    "                 #alloc_buffers='DISABLED',\n",
+    "                 #fifo_only_streaming='DISABLED',\n",
+    "                 #interleave_samples='DISABLED',\n",
+    "                 #get_processed_data='DISABLED',\n",
+    "                 allocated_buffers=1,\n",
+    "                 #buffer_timeout=1000\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4.502616118642945"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Getting the value of the parameter 'acquisition' of the instrument 'acquisition_controller' performes the entire acquisition \n",
+    "# protocol. This again depends on the specific implementation of the acquisition controller\n",
+    "acquisition_controller.acquisition()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       " 'functions': {},\n",
+       " 'name': 'Alazar1',\n",
+       " 'parameters': {'IDN': {'__class__': 'qcodes.instrument.parameter.Parameter',\n",
+       "   'full_name': 'Alazar1_IDN',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'IDN',\n",
+       "   'name': 'IDN',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': None,\n",
+       "   'ts': None,\n",
+       "   'unit': '',\n",
+       "   'vals': '<Anything>',\n",
+       "   'value': None},\n",
+       "  'alloc_buffers': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_alloc_buffers',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Alloc Buffers',\n",
+       "   'name': 'alloc_buffers',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'DISABLED',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'ENABLED', 'DISABLED'}>\",\n",
+       "   'value': 'DISABLED'},\n",
+       "  'allocated_buffers': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_allocated_buffers',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Allocated Buffers',\n",
+       "   'name': 'allocated_buffers',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 1,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': '<Ints v>=0>',\n",
+       "   'value': 1},\n",
+       "  'aux_io_mode': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_aux_io_mode',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'AUX I/O Mode',\n",
+       "   'name': 'aux_io_mode',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'AUX_IN_AUXILIARY',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'AUX_IN_TRIGGER_ENABLE', 'AUX_OUT_TRIGGER', 'AUX_IN_AUXILIARY'}>\",\n",
+       "   'value': 'AUX_IN_AUXILIARY'},\n",
+       "  'aux_io_param': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_aux_io_param',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'aux_io_param',\n",
+       "   'name': 'aux_io_param',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'NONE',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'NONE', 'TRIG_SLOPE_NEGATIVE', 'TRIG_SLOPE_POSITIVE'}>\",\n",
+       "   'value': 'NONE'},\n",
+       "  'buffer_timeout': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_buffer_timeout',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Buffer Timeout',\n",
+       "   'name': 'buffer_timeout',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 1000,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': 'ms',\n",
+       "   'vals': '<Ints v>=0>',\n",
+       "   'value': 1000},\n",
+       "  'buffers_per_acquisition': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_buffers_per_acquisition',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Buffers per Acquisition',\n",
+       "   'name': 'buffers_per_acquisition',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 1,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': '<Ints v>=0>',\n",
+       "   'value': 1},\n",
+       "  'channel_range1': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_channel_range1',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Range channel 1',\n",
+       "   'name': 'channel_range1',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 0.4,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': 'V',\n",
+       "   'vals': '<Enum: {0.4}>',\n",
+       "   'value': 0.4},\n",
+       "  'channel_range2': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_channel_range2',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Range channel 2',\n",
+       "   'name': 'channel_range2',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 0.4,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': 'V',\n",
+       "   'vals': '<Enum: {0.4}>',\n",
+       "   'value': 0.4},\n",
+       "  'channel_selection': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_channel_selection',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Channel Selection',\n",
+       "   'name': 'channel_selection',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'AB',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'AB', 'B', 'A'}>\",\n",
+       "   'value': 'AB'},\n",
+       "  'clock_edge': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_clock_edge',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Clock Edge',\n",
+       "   'name': 'clock_edge',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'CLOCK_EDGE_RISING',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'CLOCK_EDGE_FALLING', 'CLOCK_EDGE_RISING'}>\",\n",
+       "   'value': 'CLOCK_EDGE_RISING'},\n",
+       "  'clock_source': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_clock_source',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Clock Source',\n",
+       "   'name': 'clock_source',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'INTERNAL_CLOCK',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'EXTERNAL_CLOCK_10MHz_REF', 'INTERNAL_CLOCK', 'FAST_EXTERNAL_CLOCK'}>\",\n",
+       "   'value': 'INTERNAL_CLOCK'},\n",
+       "  'coupling1': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_coupling1',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Coupling channel 1',\n",
+       "   'name': 'coupling1',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'DC',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'AC', 'DC'}>\",\n",
+       "   'value': 'DC'},\n",
+       "  'coupling2': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_coupling2',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Coupling channel 2',\n",
+       "   'name': 'coupling2',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'DC',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'AC', 'DC'}>\",\n",
+       "   'value': 'DC'},\n",
+       "  'decimation': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_decimation',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Decimation',\n",
+       "   'name': 'decimation',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 1,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': '<Ints 0<=v<=100000>',\n",
+       "   'value': 1},\n",
+       "  'effective_sample_rate': {'__class__': 'qcodes.instrument_drivers.AlazarTech.acquisition_parameters.EffectiveSampleRateParameter',\n",
+       "   'full_name': 'Alazar1_effective_sample_rate',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'effective_sample_rate',\n",
+       "   'name': 'effective_sample_rate',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 1000000000.0,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': 'Hz',\n",
+       "   'value': 1000000000.0},\n",
+       "  'enable_record_headers': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_enable_record_headers',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Enable Record Headers',\n",
+       "   'name': 'enable_record_headers',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'DISABLED',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'ENABLED', 'DISABLED'}>\",\n",
+       "   'value': 'DISABLED'},\n",
+       "  'external_sample_rate': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_external_sample_rate',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'External Sample Rate',\n",
+       "   'name': 'external_sample_rate',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 500000000,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': 'S/s',\n",
+       "   'vals': '<Anything>',\n",
+       "   'value': 500000000},\n",
+       "  'external_startcapture': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_external_startcapture',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'External Startcapture',\n",
+       "   'name': 'external_startcapture',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'ENABLED',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'ENABLED', 'DISABLED'}>\",\n",
+       "   'value': 'ENABLED'},\n",
+       "  'external_trigger_coupling': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_external_trigger_coupling',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'External Trigger Coupling',\n",
+       "   'name': 'external_trigger_coupling',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'DC',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'AC', 'DC'}>\",\n",
+       "   'value': 'DC'},\n",
+       "  'external_trigger_range': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_external_trigger_range',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'External Trigger Range',\n",
+       "   'name': 'external_trigger_range',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'ETR_2V5',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'ETR_1V', 'ETR_5V', 'ETR_TTL', 'ETR_2V5'}>\",\n",
+       "   'value': 'ETR_2V5'},\n",
+       "  'fifo_only_streaming': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_fifo_only_streaming',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Fifo Only Streaming',\n",
+       "   'name': 'fifo_only_streaming',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'DISABLED',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'ENABLED', 'DISABLED'}>\",\n",
+       "   'value': 'DISABLED'},\n",
+       "  'get_processed_data': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_get_processed_data',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Get Processed Data',\n",
+       "   'name': 'get_processed_data',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'DISABLED',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'ENABLED', 'DISABLED'}>\",\n",
+       "   'value': 'DISABLED'},\n",
+       "  'impedance1': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_impedance1',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Impedance channel 1',\n",
+       "   'name': 'impedance1',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 50,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': 'Ohm',\n",
+       "   'vals': '<Enum: {50}>',\n",
+       "   'value': 50},\n",
+       "  'impedance2': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_impedance2',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Impedance channel 2',\n",
+       "   'name': 'impedance2',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 50,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': 'Ohm',\n",
+       "   'vals': '<Enum: {50}>',\n",
+       "   'value': 50},\n",
+       "  'interleave_samples': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_interleave_samples',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Interleave Samples',\n",
+       "   'name': 'interleave_samples',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'DISABLED',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'ENABLED', 'DISABLED'}>\",\n",
+       "   'value': 'DISABLED'},\n",
+       "  'mode': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_mode',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Acquisition mode',\n",
+       "   'name': 'mode',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'NPT',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'NPT', 'TS'}>\",\n",
+       "   'value': 'NPT'},\n",
+       "  'records_per_buffer': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_records_per_buffer',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Records per Buffer',\n",
+       "   'name': 'records_per_buffer',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 70,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': '<Ints v>=0>',\n",
+       "   'value': 70},\n",
+       "  'sample_rate': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_sample_rate',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Internal Sample Rate',\n",
+       "   'name': 'sample_rate',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 1000000000,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': 'S/s',\n",
+       "   'vals': '<Enum: {2000000, 10000000, 20000000, 50000000, 100000000, 180000000, 160000000, 200000000, 5000, 250000000, 10000, 1800000000, 20000, 100000, 500000, 2000000000, 3600000000, 500000000, 200000, 1000000, 5000000, 25000000, 125000000, 800000000, 2400000000, 4000000000, 2000, 50000, 1000000000, 1200000000, 1000, 3000000000, 1500000000}>',\n",
+       "   'value': 1000000000},\n",
+       "  'samples_per_record': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_samples_per_record',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Samples per Record',\n",
+       "   'name': 'samples_per_record',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 1024,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': '<Ints v>=256, Multiples of 128>',\n",
+       "   'value': 1024},\n",
+       "  'timeout_ticks': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_timeout_ticks',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Timeout Ticks',\n",
+       "   'name': 'timeout_ticks',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 0,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '10 us',\n",
+       "   'vals': '<Ints v>=0>',\n",
+       "   'value': 0},\n",
+       "  'transfer_offset': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_transfer_offset',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Transfer Offset',\n",
+       "   'name': 'transfer_offset',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 0,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': 'Samples',\n",
+       "   'vals': '<Ints v>=0>',\n",
+       "   'value': 0},\n",
+       "  'trigger_delay': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_trigger_delay',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Trigger Delay',\n",
+       "   'name': 'trigger_delay',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 0,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': 'Sample clock cycles',\n",
+       "   'vals': '<Ints v>=0>',\n",
+       "   'value': 0},\n",
+       "  'trigger_engine1': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_trigger_engine1',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Trigger Engine 1',\n",
+       "   'name': 'trigger_engine1',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'TRIG_ENGINE_J',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'TRIG_ENGINE_K', 'TRIG_ENGINE_J'}>\",\n",
+       "   'value': 'TRIG_ENGINE_J'},\n",
+       "  'trigger_engine2': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_trigger_engine2',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Trigger Engine 2',\n",
+       "   'name': 'trigger_engine2',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'TRIG_ENGINE_K',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'TRIG_ENGINE_K', 'TRIG_ENGINE_J'}>\",\n",
+       "   'value': 'TRIG_ENGINE_K'},\n",
+       "  'trigger_level1': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_trigger_level1',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Trigger Level 1',\n",
+       "   'name': 'trigger_level1',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 160,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': '<Ints 0<=v<=255>',\n",
+       "   'value': 160},\n",
+       "  'trigger_level2': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_trigger_level2',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Trigger Level 2',\n",
+       "   'name': 'trigger_level2',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 128,\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': '<Ints 0<=v<=255>',\n",
+       "   'value': 128},\n",
+       "  'trigger_operation': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_trigger_operation',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Trigger Operation',\n",
+       "   'name': 'trigger_operation',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'TRIG_ENGINE_OP_J',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'TRIG_ENGINE_OP_J_AND_NOT_K', 'TRIG_ENGINE_OP_J_OR_K', 'TRIG_ENGINE_OP_J_AND_K', 'TRIG_ENGINE_OP_NOT_J_AND_K', 'TRIG_ENGINE_OP_J_XOR_K', 'TRIG_ENGINE_OP_J', 'TRIG_ENGINE_OP_K'}>\",\n",
+       "   'value': 'TRIG_ENGINE_OP_J'},\n",
+       "  'trigger_slope1': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_trigger_slope1',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Trigger Slope 1',\n",
+       "   'name': 'trigger_slope1',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'TRIG_SLOPE_POSITIVE',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'TRIG_SLOPE_NEGATIVE', 'TRIG_SLOPE_POSITIVE'}>\",\n",
+       "   'value': 'TRIG_SLOPE_POSITIVE'},\n",
+       "  'trigger_slope2': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_trigger_slope2',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Trigger Slope 2',\n",
+       "   'name': 'trigger_slope2',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'TRIG_SLOPE_POSITIVE',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'TRIG_SLOPE_NEGATIVE', 'TRIG_SLOPE_POSITIVE'}>\",\n",
+       "   'value': 'TRIG_SLOPE_POSITIVE'},\n",
+       "  'trigger_source1': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_trigger_source1',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Trigger Source 1',\n",
+       "   'name': 'trigger_source1',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'EXTERNAL',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'EXTERNAL', 'DISABLE', 'CHANNEL_A', 'CHANNEL_B'}>\",\n",
+       "   'value': 'EXTERNAL'},\n",
+       "  'trigger_source2': {'__class__': 'qcodes.instrument_drivers.AlazarTech.ATS.AlazarParameter',\n",
+       "   'full_name': 'Alazar1_trigger_source2',\n",
+       "   'instrument': 'qcodes.instrument_drivers.AlazarTech.ATS9360.AlazarTech_ATS9360',\n",
+       "   'instrument_name': 'Alazar1',\n",
+       "   'inter_delay': 0,\n",
+       "   'label': 'Trigger Source 2',\n",
+       "   'name': 'trigger_source2',\n",
+       "   'post_delay': 0,\n",
+       "   'raw_value': 'DISABLE',\n",
+       "   'ts': '2017-11-09 18:08:02',\n",
+       "   'unit': '',\n",
+       "   'vals': \"<Enum: {'EXTERNAL', 'DISABLE', 'CHANNEL_A', 'CHANNEL_B'}>\",\n",
+       "   'value': 'DISABLE'}},\n",
+       " 'submodules': {}}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# make a snapshot of the 'ats_inst' instrument\n",
+    "ats_inst.snapshot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Started at 2017-11-09 18:08:04\n",
+      "DataSet:\n",
+      "   location = 'data/2017-11-09/#005_AlazarTest_18-08-04'\n",
+      "   <Type>   | <array_id>                         | <array.name> | <array.shape>\n",
+      "   Setpoint | dummy_set                          | dummy        | (50,)\n",
+      "   Measured | acquisition_controller_acquisition | acquisition  | (50,)\n",
+      "Finished at 2017-11-09 18:08:08\n"
+     ]
+    },
+    {
+     "data": {
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "window.mpl = {};\n",
+       "\n",
+       "\n",
+       "mpl.get_websocket_type = function() {\n",
+       "    if (typeof(WebSocket) !== 'undefined') {\n",
+       "        return WebSocket;\n",
+       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
+       "        return MozWebSocket;\n",
+       "    } else {\n",
+       "        alert('Your browser does not have WebSocket support.' +\n",
+       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+       "              'Firefox 4 and 5 are also supported but you ' +\n",
+       "              'have to enable WebSockets in about:config.');\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
+       "    this.id = figure_id;\n",
+       "\n",
+       "    this.ws = websocket;\n",
+       "\n",
+       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
+       "\n",
+       "    if (!this.supports_binary) {\n",
+       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
+       "        if (warnings) {\n",
+       "            warnings.style.display = 'block';\n",
+       "            warnings.textContent = (\n",
+       "                \"This browser does not support binary websocket messages. \" +\n",
+       "                    \"Performance may be slow.\");\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.imageObj = new Image();\n",
+       "\n",
+       "    this.context = undefined;\n",
+       "    this.message = undefined;\n",
+       "    this.canvas = undefined;\n",
+       "    this.rubberband_canvas = undefined;\n",
+       "    this.rubberband_context = undefined;\n",
+       "    this.format_dropdown = undefined;\n",
+       "\n",
+       "    this.image_mode = 'full';\n",
+       "\n",
+       "    this.root = $('<div/>');\n",
+       "    this._root_extra_style(this.root)\n",
+       "    this.root.attr('style', 'display: inline-block');\n",
+       "\n",
+       "    $(parent_element).append(this.root);\n",
+       "\n",
+       "    this._init_header(this);\n",
+       "    this._init_canvas(this);\n",
+       "    this._init_toolbar(this);\n",
+       "\n",
+       "    var fig = this;\n",
+       "\n",
+       "    this.waiting = false;\n",
+       "\n",
+       "    this.ws.onopen =  function () {\n",
+       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
+       "            fig.send_message(\"send_image_mode\", {});\n",
+       "            if (mpl.ratio != 1) {\n",
+       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
+       "            }\n",
+       "            fig.send_message(\"refresh\", {});\n",
+       "        }\n",
+       "\n",
+       "    this.imageObj.onload = function() {\n",
+       "            if (fig.image_mode == 'full') {\n",
+       "                // Full images could contain transparency (where diff images\n",
+       "                // almost always do), so we need to clear the canvas so that\n",
+       "                // there is no ghosting.\n",
+       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "            }\n",
+       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
+       "        };\n",
+       "\n",
+       "    this.imageObj.onunload = function() {\n",
+       "        fig.ws.close();\n",
+       "    }\n",
+       "\n",
+       "    this.ws.onmessage = this._make_on_message_function(this);\n",
+       "\n",
+       "    this.ondownload = ondownload;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_header = function() {\n",
+       "    var titlebar = $(\n",
+       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
+       "        'ui-helper-clearfix\"/>');\n",
+       "    var titletext = $(\n",
+       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
+       "        'text-align: center; padding: 3px;\"/>');\n",
+       "    titlebar.append(titletext)\n",
+       "    this.root.append(titlebar);\n",
+       "    this.header = titletext[0];\n",
+       "}\n",
+       "\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_canvas = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var canvas_div = $('<div/>');\n",
+       "\n",
+       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
+       "\n",
+       "    function canvas_keyboard_event(event) {\n",
+       "        return fig.key_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
+       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
+       "    this.canvas_div = canvas_div\n",
+       "    this._canvas_extra_style(canvas_div)\n",
+       "    this.root.append(canvas_div);\n",
+       "\n",
+       "    var canvas = $('<canvas/>');\n",
+       "    canvas.addClass('mpl-canvas');\n",
+       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
+       "\n",
+       "    this.canvas = canvas[0];\n",
+       "    this.context = canvas[0].getContext(\"2d\");\n",
+       "\n",
+       "    var backingStore = this.context.backingStorePixelRatio ||\n",
+       "\tthis.context.webkitBackingStorePixelRatio ||\n",
+       "\tthis.context.mozBackingStorePixelRatio ||\n",
+       "\tthis.context.msBackingStorePixelRatio ||\n",
+       "\tthis.context.oBackingStorePixelRatio ||\n",
+       "\tthis.context.backingStorePixelRatio || 1;\n",
+       "\n",
+       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+       "\n",
+       "    var rubberband = $('<canvas/>');\n",
+       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
+       "\n",
+       "    var pass_mouse_events = true;\n",
+       "\n",
+       "    canvas_div.resizable({\n",
+       "        start: function(event, ui) {\n",
+       "            pass_mouse_events = false;\n",
+       "        },\n",
+       "        resize: function(event, ui) {\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "        stop: function(event, ui) {\n",
+       "            pass_mouse_events = true;\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "    });\n",
+       "\n",
+       "    function mouse_event_fn(event) {\n",
+       "        if (pass_mouse_events)\n",
+       "            return fig.mouse_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
+       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
+       "    // Throttle sequential mouse events to 1 every 20ms.\n",
+       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
+       "\n",
+       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
+       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
+       "\n",
+       "    canvas_div.on(\"wheel\", function (event) {\n",
+       "        event = event.originalEvent;\n",
+       "        event['data'] = 'scroll'\n",
+       "        if (event.deltaY < 0) {\n",
+       "            event.step = 1;\n",
+       "        } else {\n",
+       "            event.step = -1;\n",
+       "        }\n",
+       "        mouse_event_fn(event);\n",
+       "    });\n",
+       "\n",
+       "    canvas_div.append(canvas);\n",
+       "    canvas_div.append(rubberband);\n",
+       "\n",
+       "    this.rubberband = rubberband;\n",
+       "    this.rubberband_canvas = rubberband[0];\n",
+       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
+       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
+       "\n",
+       "    this._resize_canvas = function(width, height) {\n",
+       "        // Keep the size of the canvas, canvas container, and rubber band\n",
+       "        // canvas in synch.\n",
+       "        canvas_div.css('width', width)\n",
+       "        canvas_div.css('height', height)\n",
+       "\n",
+       "        canvas.attr('width', width * mpl.ratio);\n",
+       "        canvas.attr('height', height * mpl.ratio);\n",
+       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
+       "\n",
+       "        rubberband.attr('width', width);\n",
+       "        rubberband.attr('height', height);\n",
+       "    }\n",
+       "\n",
+       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
+       "    // upon first draw.\n",
+       "    this._resize_canvas(600, 600);\n",
+       "\n",
+       "    // Disable right mouse context menu.\n",
+       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
+       "        return false;\n",
+       "    });\n",
+       "\n",
+       "    function set_focus () {\n",
+       "        canvas.focus();\n",
+       "        canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    window.setTimeout(set_focus, 100);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            // put a spacer in here.\n",
+       "            continue;\n",
+       "        }\n",
+       "        var button = $('<button/>');\n",
+       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
+       "                        'ui-button-icon-only');\n",
+       "        button.attr('role', 'button');\n",
+       "        button.attr('aria-disabled', 'false');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "\n",
+       "        var icon_img = $('<span/>');\n",
+       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
+       "        icon_img.addClass(image);\n",
+       "        icon_img.addClass('ui-corner-all');\n",
+       "\n",
+       "        var tooltip_span = $('<span/>');\n",
+       "        tooltip_span.addClass('ui-button-text');\n",
+       "        tooltip_span.html(tooltip);\n",
+       "\n",
+       "        button.append(icon_img);\n",
+       "        button.append(tooltip_span);\n",
+       "\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    var fmt_picker_span = $('<span/>');\n",
+       "\n",
+       "    var fmt_picker = $('<select/>');\n",
+       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
+       "    fmt_picker_span.append(fmt_picker);\n",
+       "    nav_element.append(fmt_picker_span);\n",
+       "    this.format_dropdown = fmt_picker[0];\n",
+       "\n",
+       "    for (var ind in mpl.extensions) {\n",
+       "        var fmt = mpl.extensions[ind];\n",
+       "        var option = $(\n",
+       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
+       "        fmt_picker.append(option)\n",
+       "    }\n",
+       "\n",
+       "    // Add hover states to the ui-buttons\n",
+       "    $( \".ui-button\" ).hover(\n",
+       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
+       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
+       "    );\n",
+       "\n",
+       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
+       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+       "    // which will in turn request a refresh of the image.\n",
+       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_message = function(type, properties) {\n",
+       "    properties['type'] = type;\n",
+       "    properties['figure_id'] = this.id;\n",
+       "    this.ws.send(JSON.stringify(properties));\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_draw_message = function() {\n",
+       "    if (!this.waiting) {\n",
+       "        this.waiting = true;\n",
+       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    var format_dropdown = fig.format_dropdown;\n",
+       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+       "    fig.ondownload(fig, format);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
+       "    var size = msg['size'];\n",
+       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
+       "        fig._resize_canvas(size[0], size[1]);\n",
+       "        fig.send_message(\"refresh\", {});\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
+       "    var x0 = msg['x0'] / mpl.ratio;\n",
+       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
+       "    var x1 = msg['x1'] / mpl.ratio;\n",
+       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
+       "    x0 = Math.floor(x0) + 0.5;\n",
+       "    y0 = Math.floor(y0) + 0.5;\n",
+       "    x1 = Math.floor(x1) + 0.5;\n",
+       "    y1 = Math.floor(y1) + 0.5;\n",
+       "    var min_x = Math.min(x0, x1);\n",
+       "    var min_y = Math.min(y0, y1);\n",
+       "    var width = Math.abs(x1 - x0);\n",
+       "    var height = Math.abs(y1 - y0);\n",
+       "\n",
+       "    fig.rubberband_context.clearRect(\n",
+       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "\n",
+       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
+       "    // Updates the figure title.\n",
+       "    fig.header.textContent = msg['label'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
+       "    var cursor = msg['cursor'];\n",
+       "    switch(cursor)\n",
+       "    {\n",
+       "    case 0:\n",
+       "        cursor = 'pointer';\n",
+       "        break;\n",
+       "    case 1:\n",
+       "        cursor = 'default';\n",
+       "        break;\n",
+       "    case 2:\n",
+       "        cursor = 'crosshair';\n",
+       "        break;\n",
+       "    case 3:\n",
+       "        cursor = 'move';\n",
+       "        break;\n",
+       "    }\n",
+       "    fig.rubberband_canvas.style.cursor = cursor;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
+       "    fig.message.textContent = msg['message'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
+       "    // Request the server to send over a new figure.\n",
+       "    fig.send_draw_message();\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
+       "    fig.image_mode = msg['mode'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Called whenever the canvas gets updated.\n",
+       "    this.send_message(\"ack\", {});\n",
+       "}\n",
+       "\n",
+       "// A function to construct a web socket function for onmessage handling.\n",
+       "// Called in the figure constructor.\n",
+       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
+       "    return function socket_on_message(evt) {\n",
+       "        if (evt.data instanceof Blob) {\n",
+       "            /* FIXME: We get \"Resource interpreted as Image but\n",
+       "             * transferred with MIME type text/plain:\" errors on\n",
+       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+       "             * to be part of the websocket stream */\n",
+       "            evt.data.type = \"image/png\";\n",
+       "\n",
+       "            /* Free the memory for the previous frames */\n",
+       "            if (fig.imageObj.src) {\n",
+       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+       "                    fig.imageObj.src);\n",
+       "            }\n",
+       "\n",
+       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+       "                evt.data);\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
+       "            fig.imageObj.src = evt.data;\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        var msg = JSON.parse(evt.data);\n",
+       "        var msg_type = msg['type'];\n",
+       "\n",
+       "        // Call the  \"handle_{type}\" callback, which takes\n",
+       "        // the figure and JSON message as its only arguments.\n",
+       "        try {\n",
+       "            var callback = fig[\"handle_\" + msg_type];\n",
+       "        } catch (e) {\n",
+       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        if (callback) {\n",
+       "            try {\n",
+       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+       "                callback(fig, msg);\n",
+       "            } catch (e) {\n",
+       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
+       "            }\n",
+       "        }\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+       "mpl.findpos = function(e) {\n",
+       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+       "    var targ;\n",
+       "    if (!e)\n",
+       "        e = window.event;\n",
+       "    if (e.target)\n",
+       "        targ = e.target;\n",
+       "    else if (e.srcElement)\n",
+       "        targ = e.srcElement;\n",
+       "    if (targ.nodeType == 3) // defeat Safari bug\n",
+       "        targ = targ.parentNode;\n",
+       "\n",
+       "    // jQuery normalizes the pageX and pageY\n",
+       "    // pageX,Y are the mouse positions relative to the document\n",
+       "    // offset() returns the position of the element relative to the document\n",
+       "    var x = e.pageX - $(targ).offset().left;\n",
+       "    var y = e.pageY - $(targ).offset().top;\n",
+       "\n",
+       "    return {\"x\": x, \"y\": y};\n",
+       "};\n",
+       "\n",
+       "/*\n",
+       " * return a copy of an object with only non-object keys\n",
+       " * we need this to avoid circular references\n",
+       " * http://stackoverflow.com/a/24161582/3208463\n",
+       " */\n",
+       "function simpleKeys (original) {\n",
+       "  return Object.keys(original).reduce(function (obj, key) {\n",
+       "    if (typeof original[key] !== 'object')\n",
+       "        obj[key] = original[key]\n",
+       "    return obj;\n",
+       "  }, {});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
+       "    var canvas_pos = mpl.findpos(event)\n",
+       "\n",
+       "    if (name === 'button_press')\n",
+       "    {\n",
+       "        this.canvas.focus();\n",
+       "        this.canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    var x = canvas_pos.x * mpl.ratio;\n",
+       "    var y = canvas_pos.y * mpl.ratio;\n",
+       "\n",
+       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
+       "                             step: event.step,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "\n",
+       "    /* This prevents the web browser from automatically changing to\n",
+       "     * the text insertion cursor when the button is pressed.  We want\n",
+       "     * to control all of the cursor setting manually through the\n",
+       "     * 'cursor' event from matplotlib */\n",
+       "    event.preventDefault();\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    // Handle any extra behaviour associated with a key event\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.key_event = function(event, name) {\n",
+       "\n",
+       "    // Prevent repeat events\n",
+       "    if (name == 'key_press')\n",
+       "    {\n",
+       "        if (event.which === this._key)\n",
+       "            return;\n",
+       "        else\n",
+       "            this._key = event.which;\n",
+       "    }\n",
+       "    if (name == 'key_release')\n",
+       "        this._key = null;\n",
+       "\n",
+       "    var value = '';\n",
+       "    if (event.ctrlKey && event.which != 17)\n",
+       "        value += \"ctrl+\";\n",
+       "    if (event.altKey && event.which != 18)\n",
+       "        value += \"alt+\";\n",
+       "    if (event.shiftKey && event.which != 16)\n",
+       "        value += \"shift+\";\n",
+       "\n",
+       "    value += 'k';\n",
+       "    value += event.which.toString();\n",
+       "\n",
+       "    this._key_event_extra(event, name);\n",
+       "\n",
+       "    this.send_message(name, {key: value,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
+       "    if (name == 'download') {\n",
+       "        this.handle_save(this, null);\n",
+       "    } else {\n",
+       "        this.send_message(\"toolbar_button\", {name: name});\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
+       "    this.message.textContent = tooltip;\n",
+       "};\n",
+       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+       "\n",
+       "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n",
+       "\n",
+       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
+       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+       "    // object with the appropriate methods. Currently this is a non binary\n",
+       "    // socket, so there is still some room for performance tuning.\n",
+       "    var ws = {};\n",
+       "\n",
+       "    ws.close = function() {\n",
+       "        comm.close()\n",
+       "    };\n",
+       "    ws.send = function(m) {\n",
+       "        //console.log('sending', m);\n",
+       "        comm.send(m);\n",
+       "    };\n",
+       "    // Register the callback with on_msg.\n",
+       "    comm.on_msg(function(msg) {\n",
+       "        //console.log('receiving', msg['content']['data'], msg);\n",
+       "        // Pass the mpl event to the overriden (by mpl) onmessage function.\n",
+       "        ws.onmessage(msg['content']['data'])\n",
+       "    });\n",
+       "    return ws;\n",
+       "}\n",
+       "\n",
+       "mpl.mpl_figure_comm = function(comm, msg) {\n",
+       "    // This is the function which gets called when the mpl process\n",
+       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+       "\n",
+       "    var id = msg.content.data.id;\n",
+       "    // Get hold of the div created by the display call when the Comm\n",
+       "    // socket was opened in Python.\n",
+       "    var element = $(\"#\" + id);\n",
+       "    var ws_proxy = comm_websocket_adapter(comm)\n",
+       "\n",
+       "    function ondownload(figure, format) {\n",
+       "        window.open(figure.imageObj.src);\n",
+       "    }\n",
+       "\n",
+       "    var fig = new mpl.figure(id, ws_proxy,\n",
+       "                           ondownload,\n",
+       "                           element.get(0));\n",
+       "\n",
+       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+       "    // web socket which is closed, not our websocket->open comm proxy.\n",
+       "    ws_proxy.onopen();\n",
+       "\n",
+       "    fig.parent_element = element.get(0);\n",
+       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+       "    if (!fig.cell_info) {\n",
+       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
+       "        return;\n",
+       "    }\n",
+       "\n",
+       "    var output_index = fig.cell_info[2]\n",
+       "    var cell = fig.cell_info[0];\n",
+       "\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
+       "    var width = fig.canvas.width/mpl.ratio\n",
+       "    fig.root.unbind('remove')\n",
+       "\n",
+       "    // Update the output cell to use the data from the current canvas.\n",
+       "    fig.push_to_output();\n",
+       "    var dataURL = fig.canvas.toDataURL();\n",
+       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+       "    // the notebook keyboard shortcuts fail.\n",
+       "    IPython.keyboard_manager.enable()\n",
+       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
+       "    fig.close_ws(fig, msg);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
+       "    fig.send_message('closing', msg);\n",
+       "    // fig.ws.close()\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
+       "    // Turn the data on the canvas into data in the output cell.\n",
+       "    var width = this.canvas.width/mpl.ratio\n",
+       "    var dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message(\"ack\", {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items){\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) { continue; };\n",
+       "\n",
+       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
+       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
+       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
+       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
+       "    buttongrp.append(button);\n",
+       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
+       "    titlebar.prepend(buttongrp);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(el){\n",
+       "    var fig = this\n",
+       "    el.on(\"remove\", function(){\n",
+       "\tfig.close_ws(fig, {});\n",
+       "    });\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.attr('tabindex', 0)\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "    else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager)\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which == 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        event.shiftKey = false;\n",
+       "        // Send a \"J\" for go to next cell\n",
+       "        event.which = 74;\n",
+       "        event.keyCode = 74;\n",
+       "        manager.command_mode();\n",
+       "        manager.handle_keydown(event);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.find_output_cell = function(html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i=0; i<ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code'){\n",
+       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] == html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel != null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
+       "}\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,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\" width=\"600\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<qcodes.plots.qcmatplotlib.MatPlot at 0x1cb5b6b5cc0>"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Finally show that this instrument also works within a loop\n",
+    "dummy = parameter.ManualParameter(name=\"dummy\")\n",
+    "data = qc.Loop(dummy[0:50:1]).each(acquisition_controller.acquisition).run(name='AlazarTest')\n",
+    "qc.MatPlot(data.acquisition_controller_acquisition)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "anaconda-cloud": {},
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/qcodes/instrument_drivers/AlazarTech/ATS.py b/qcodes/instrument_drivers/AlazarTech/ATS.py
index 98ba18443e95..6335c31658f9 100644
--- a/qcodes/instrument_drivers/AlazarTech/ATS.py
+++ b/qcodes/instrument_drivers/AlazarTech/ATS.py
@@ -1,23 +1,26 @@
 import ctypes
 import logging
 import numpy as np
+import time
 import os
 
 from qcodes.instrument.base import Instrument
 from qcodes.instrument.parameter import Parameter
 from qcodes.utils import validators
 
+logger = logging.getLogger(__name__)
+
 # TODO(damazter) (C) logging
 
 # these items are important for generalizing this code to multiple alazar cards
-# TODO(damazter) (W) remove 8 bits per sample requirement
 # TODO(damazter) (W) some alazar cards have a different number of channels :(
-# this driver only works with 2-channel cards
 
 # TODO(damazter) (S) tests to do:
 # acquisition that would overflow the board if measurement is not stopped
 # quickly enough. can this be solved by not reposting the buffers?
 
+# TODO (natalie) make logging vs print vs nothing decisions
+
 
 class AlazarTech_ATS(Instrument):
     """
@@ -33,7 +36,7 @@ class AlazarTech_ATS(Instrument):
         name: name for this instrument, passed to the base instrument
         system_id: target system id for this instrument
         board_id: target board id within the system for this instrument
-        dll_path: string contianing the path of the ATS driver dll
+        dll_path: string containing the path of the ATS driver dll
 
     """
     # override dll_path in your init script or in the board constructor
@@ -193,13 +196,14 @@ def find_boards(cls, dll_path=None):
                 boards.append(cls.get_board_info(dll, system_id, board_id))
         return boards
 
+        # TODO(nataliejpg) this needs fixing..., dll can't be a string
     @classmethod
     def get_board_info(cls, dll, system_id, board_id):
         """
         Get the information from a connected Alazar board
 
         Args:
-            dll (string): path of the Alazar driver dll
+            dll (CDLL): CTypes CDLL
             system_id: id of the Alazar system
             board_id: id of the board within the alazar system
 
@@ -213,7 +217,6 @@ def get_board_info(cls, dll, system_id, board_id):
                 - max_samples
                 - bits_per_sample
         """
-
         # make a temporary instrument for this board, to make it easier
         # to get its info
         board = cls('temp', system_id=system_id, board_id=board_id,
@@ -232,7 +235,12 @@ def get_board_info(cls, dll, system_id, board_id):
 
     def __init__(self, name, system_id=1, board_id=1, dll_path=None, **kwargs):
         super().__init__(name, **kwargs)
-        self._ATS_dll = ctypes.cdll.LoadLibrary(dll_path or self.dll_path)
+        self._ATS_dll = None
+
+        if os.name == 'nt':
+            self._ATS_dll = ctypes.cdll.LoadLibrary(dll_path or self.dll_path)
+        else:
+            raise Exception("Unsupported OS")
 
         self._handle = self._ATS_dll.AlazarGetBoardBySystemID(system_id,
                                                               board_id)
@@ -242,6 +250,26 @@ def __init__(self, name, system_id=1, board_id=1, dll_path=None, **kwargs):
 
         self.buffer_list = []
 
+        self._ATS_dll.AlazarWaitAsyncBufferComplete.argtypes = [
+            ctypes.c_uint32, ctypes.c_void_p, ctypes.c_uint32]
+        self._ATS_dll.AlazarBeforeAsyncRead.argtypes = [ctypes.c_uint32,
+                                                        ctypes.c_uint32,
+                                                        ctypes.c_long,
+                                                        ctypes.c_uint32,
+                                                        ctypes.c_uint32,
+                                                        ctypes.c_uint32,
+                                                        ctypes.c_uint32]
+        self._ATS_dll.AlazarPostAsyncBuffer.argtypes = [ctypes.c_uint32,
+                                                        ctypes.c_void_p,
+                                                        ctypes.c_uint32]
+        ctypes.windll.kernel32.VirtualAlloc.argtypes = [ctypes.c_void_p,
+                                                        ctypes.c_long,
+                                                        ctypes.c_long,
+                                                        ctypes.c_long]
+        ctypes.windll.kernel32.VirtualFree.argtypes = [ctypes.c_void_p,
+                                                       ctypes.c_long,
+                                                       ctypes.c_long]
+
     def get_idn(self):
         """
         This methods gets the most relevant information of this instrument
@@ -266,56 +294,60 @@ def get_idn(self):
         board_kind = self._board_names[
             self._ATS_dll.AlazarGetBoardKind(self._handle)]
 
-        major = np.array([0], dtype=np.uint8)
-        minor = np.array([0], dtype=np.uint8)
-        revision = np.array([0], dtype=np.uint8)
+        max_s, bps = self._get_channel_info(self._handle)
+
+        major = ctypes.c_uint8(0)
+        minor = ctypes.c_uint8(0)
+        revision = ctypes.c_uint8(0)
         self._call_dll('AlazarGetCPLDVersion',
                        self._handle,
-                       major.ctypes.data,
-                       minor.ctypes.data)
-        cpld_ver = str(major[0])+"."+str(minor[0])
+                       ctypes.byref(major),
+                       ctypes.byref(minor))
+        cpld_ver = str(major.value) + "." + str(minor.value)
 
         self._call_dll('AlazarGetDriverVersion',
-                       major.ctypes.data,
-                       minor.ctypes.data,
-                       revision.ctypes.data)
-        driver_ver = str(major[0])+"."+str(minor[0])+"."+str(revision[0])
+                       ctypes.byref(major),
+                       ctypes.byref(minor),
+                       ctypes.byref(revision))
+        driver_ver = str(major.value)+"."+str(minor.value)+"."+str(revision.value)
 
         self._call_dll('AlazarGetSDKVersion',
-                       major.ctypes.data,
-                       minor.ctypes.data,
-                       revision.ctypes.data)
-        sdk_ver = str(major[0])+"."+str(minor[0])+"."+str(revision[0])
+                       ctypes.byref(major),
+                       ctypes.byref(minor),
+                       ctypes.byref(revision))
+        sdk_ver = str(major.value)+"."+str(minor.value)+"."+str(revision.value)
 
-        value = np.array([0], dtype=np.uint32)
+        value = ctypes.c_uint32(0)
         self._call_dll('AlazarQueryCapability',
-                       self._handle, 0x10000024, 0, value.ctypes.data)
-        serial = str(value[0])
+                       self._handle, 0x10000024, 0, ctypes.byref(value))
+        serial = str(value.value)
         self._call_dll('AlazarQueryCapability',
-                       self._handle, 0x10000026, 0, value.ctypes.data)
-        latest_cal_date = (str(value[0])[0:2] + "-" +
-                           str(value[0])[2:4] + "-" +
-                           str(value[0])[4:6])
+                       self._handle, 0x10000026, 0, ctypes.byref(value))
+        Capabilitystring = str(value.value)
+        latest_cal_date = (Capabilitystring[0:2] + "-" +
+                           Capabilitystring[2:4] + "-" +
+                           Capabilitystring[4:6])
 
         self._call_dll('AlazarQueryCapability',
-                       self._handle, 0x1000002A, 0, value.ctypes.data)
-        memory_size = str(value[0])
+                       self._handle, 0x1000002A, 0, ctypes.byref(value))
+        memory_size = str(value.value)
         self._call_dll('AlazarQueryCapability',
-                       self._handle, 0x1000002C, 0, value.ctypes.data)
-        asopc_type = str(value[0])
+                       self._handle, 0x1000002C, 0, ctypes.byref(value))
+        asopc_type = str(value.value)
 
         # see the ATS-SDK programmer's guide
         # about the encoding of the link speed
         self._call_dll('AlazarQueryCapability',
-                       self._handle, 0x10000030, 0, value.ctypes.data)
-        pcie_link_speed = str(value[0]*2.5/10)+"GB/s"
+                       self._handle, 0x10000030, 0,  ctypes.byref(value))
+        pcie_link_speed = str(value.value * 2.5 / 10) + "GB/s"
         self._call_dll('AlazarQueryCapability',
-                       self._handle, 0x10000031, 0, value.ctypes.data)
-        pcie_link_width = str(value[0])
-
+                       self._handle, 0x10000031, 0, ctypes.byref(value))
+        pcie_link_width = str(value.value)
 
         return {'firmware': None,
                 'model': board_kind,
+                'max_samples': max_s,
+                'bits_per_sample': bps,
                 'serial': serial,
                 'vendor': 'AlazarTech',
                 'CPLD_version': cpld_ver,
@@ -328,6 +360,7 @@ def get_idn(self):
                 'pcie_link_width': pcie_link_width}
 
     def config(self, clock_source=None, sample_rate=None, clock_edge=None,
+               external_sample_rate=None,
                decimation=None, coupling=None, channel_range=None,
                impedance=None, bwlimit=None, trigger_operation=None,
                trigger_engine1=None, trigger_source1=None,
@@ -335,7 +368,8 @@ def config(self, clock_source=None, sample_rate=None, clock_edge=None,
                trigger_engine2=None, trigger_source2=None,
                trigger_slope2=None, trigger_level2=None,
                external_trigger_coupling=None, external_trigger_range=None,
-               trigger_delay=None, timeout_ticks=None):
+               trigger_delay=None, timeout_ticks=None, aux_io_mode=None,
+               aux_io_param=None):
         """
         configure the ATS board and set the corresponding parameters to the
         appropriate values.
@@ -345,6 +379,7 @@ def config(self, clock_source=None, sample_rate=None, clock_edge=None,
             clock_source:
             sample_rate:
             clock_edge:
+            external_sample_rate:
             decimation:
             coupling:
             channel_range:
@@ -363,6 +398,8 @@ def config(self, clock_source=None, sample_rate=None, clock_edge=None,
             external_trigger_range:
             trigger_delay:
             timeout_ticks:
+            aux_io_mode:
+            aux_io_param:
 
         Returns:
             None
@@ -371,6 +408,7 @@ def config(self, clock_source=None, sample_rate=None, clock_edge=None,
 
         self._set_if_present('clock_source', clock_source)
         self._set_if_present('sample_rate', sample_rate)
+        self._set_if_present('external_sample_rate', external_sample_rate)
         self._set_if_present('clock_edge', clock_edge)
         self._set_if_present('decimation', decimation)
 
@@ -396,21 +434,49 @@ def config(self, clock_source=None, sample_rate=None, clock_edge=None,
                              external_trigger_range)
         self._set_if_present('trigger_delay', trigger_delay)
         self._set_if_present('timeout_ticks', timeout_ticks)
+        self._set_if_present('aux_io_mode', aux_io_mode)
+        self._set_if_present('aux_io_param', aux_io_param)
         # endregion
 
+        # handle that external clock and internal clock uses
+        # two different ways of setting the sample rate.
+        # We use the matching one and mark the order one
+        # as up to date since it's not being pushed to
+        # the instrument at any time and is never used
+        if sample_rate is not None and external_sample_rate is not None:
+            raise RuntimeError("Both sample_rate and external_sample_rate supplied")
+
+        if clock_source == 'EXTERNAL_CLOCK_10MHz_REF':
+            if sample_rate is not None:
+                logger.warning("Using external 10 MHz ref clock "
+                               "but internal sample rate supplied. "
+                               "Please use 'external_sample_rate'")
+            sample_rate = self.external_sample_rate
+            if 'sample_rate' in self.parameters:
+                self.parameters['sample_rate']._set_updated()
+        elif clock_source == 'INTERNAL_CLOCK':
+            sample_rate = self.sample_rate
+            if external_sample_rate is not None:
+                logger.warning("Using internal clock "
+                               "but external sample rate supplied. "
+                               "Please use 'external_sample_rate'")
+            if 'external_sample_rate' in self.parameters:
+                self.parameters['external_sample_rate']._set_updated()
+
         self._call_dll('AlazarSetCaptureClock',
-                       self._handle, self.clock_source, self.sample_rate,
+                       self._handle, self.clock_source, sample_rate,
                        self.clock_edge, self.decimation)
 
         for i in range(1, self.channels + 1):
             self._call_dll('AlazarInputControl',
-                           self._handle, i,
+                           self._handle, 2**(i-1),
                            self.parameters['coupling' + str(i)],
                            self.parameters['channel_range' + str(i)],
                            self.parameters['impedance' + str(i)])
-            self._call_dll('AlazarSetBWLimit',
-                           self._handle, i,
-                           self.parameters['bwlimit' + str(i)])
+            if bwlimit is not None:
+                self._call_dll('AlazarSetBWLimit',
+                               self._handle, 2**(i-1),
+                               self.parameters['bwlimit' + str(i)])
 
         self._call_dll('AlazarSetTriggerOperation',
                        self._handle, self.trigger_operation,
@@ -429,14 +495,18 @@ def config(self, clock_source=None, sample_rate=None, clock_edge=None,
         self._call_dll('AlazarSetTriggerTimeOut',
                        self._handle, self.timeout_ticks)
 
-        # TODO(damazter) (W) config AUXIO
+        self._call_dll('AlazarConfigureAuxIO',
+                       self._handle, self.aux_io_mode,
+                       self.aux_io_param)
 
     def _get_channel_info(self, handle):
-        bps = np.array([0], dtype=np.uint8)  # bps bits per sample
-        max_s = np.array([0], dtype=np.uint32)  # max_s memory size in samples
+        bps = ctypes.c_uint8(0)  # bps bits per sample
+        max_s = ctypes.c_uint32(0)  # max_s memory size in samples
         self._call_dll('AlazarGetChannelInfo',
-                       handle, max_s.ctypes.data, bps.ctypes.data)
-        return max_s[0], bps[0]
+                       handle,
+                       ctypes.byref(max_s),
+                       ctypes.byref(bps))
+        return max_s.value, bps.value
 
     def acquire(self, mode=None, samples_per_record=None,
                 records_per_buffer=None, buffers_per_acquisition=None,
@@ -501,11 +571,6 @@ def acquire(self, mode=None, samples_per_record=None,
         # Abort any previous measurement
         self._call_dll('AlazarAbortAsyncRead', self._handle)
 
-        # get channel info
-        max_s, bps = self._get_channel_info(self._handle)
-        if bps != 8:
-            raise Exception('Only 8 bits per sample supported at this moment')
-
         # Set record size for NPT mode
         if mode == 'NPT':
             pretriggersize = 0  # pretriggersize is 0 for NPT always
@@ -515,10 +580,6 @@ def acquire(self, mode=None, samples_per_record=None,
                            post_trigger_size)
 
         # set acquisition parameters here for NPT, TS mode
-        if self.channel_selection._get_byte() == 3:
-            number_of_channels = 2
-        else:
-            number_of_channels = 1
         samples_per_buffer = 0
         buffers_per_acquisition = self.buffers_per_acquisition._get_byte()
         samples_per_record = self.samples_per_record._get_byte()
@@ -535,7 +596,6 @@ def acquire(self, mode=None, samples_per_record=None,
             records_per_acquisition = (
                 records_per_buffer * buffers_per_acquisition)
             samples_per_buffer = samples_per_record * records_per_buffer
-
             self._call_dll('AlazarBeforeAsyncRead',
                            self._handle, self.channel_selection,
                            self.transfer_offset, samples_per_record,
@@ -544,14 +604,14 @@ def acquire(self, mode=None, samples_per_record=None,
 
         elif mode == 'TS':
             if (samples_per_record % buffers_per_acquisition != 0):
-                logging.warning('buffers_per_acquisition is not a divisor of '
-                                'samples per record which it should be in '
-                                'TS mode, rounding down in samples per buffer '
-                                'calculation')
+                logger.warning('buffers_per_acquisition is not a divisor of '
+                               'samples per record which it should be in '
+                               'Ts mode, rounding down in samples per buffer '
+                               'calculation')
             samples_per_buffer = int(samples_per_record /
                                      buffers_per_acquisition)
             if self.records_per_buffer._get_byte() != 1:
-                logging.warning('records_per_buffer should be 1 in TS mode, '
+                logger.warning('records_per_buffer should be 1 in TS mode, '
                                 'defauling to 1')
                 self.records_per_buffer._set(1)
             records_per_buffer = self.records_per_buffer._get_byte()
@@ -574,14 +634,35 @@ def acquire(self, mode=None, samples_per_record=None,
         self.interleave_samples._set_updated()
         self.get_processed_data._set_updated()
 
+        # bytes per sample
+        max_s, bps = self._get_channel_info(self._handle)
+        # TODO(JHN) Why +7 I guess its to do ceil division?
+        bytes_per_sample = (bps + 7) // 8
+        # bytes per record
+        bytes_per_record = bytes_per_sample * samples_per_record
+
+        # channels
+        channels_binrep = self.channel_selection._get_byte()
+        number_of_channels = self.get_num_channels(channels_binrep)
+
+        # bytes per buffer
+        bytes_per_buffer = (bytes_per_record *
+                            records_per_buffer * number_of_channels)
+
         # create buffers for acquisition
+        # TODO(nataliejpg) should this be > 1 (as intuitive) or > 8 as in alazar sample code?
+        # the alazar code probably uses bits per sample?
+        sample_type = ctypes.c_uint8
+        if bytes_per_sample > 1:
+            sample_type = ctypes.c_uint16
+
         self.clear_buffers()
         # make sure that allocated_buffers <= buffers_per_acquisition
         if (self.allocated_buffers._get_byte() >
                 self.buffers_per_acquisition._get_byte()):
-            print("'allocated_buffers' should be smaller than or equal to"
-                  "'buffers_per_acquisition'. Defaulting 'allocated_buffers' to"
-                  "" + str(self.buffers_per_acquisition._get_byte()))
+            logger.warning("'allocated_buffers' should be <= "
+                           "'buffers_per_acquisition'. Defaulting 'allocated_buffers'"
+                           " to " + str(self.buffers_per_acquisition._get_byte()))
             self.allocated_buffers._set(
                 self.buffers_per_acquisition._get_byte())
 
@@ -589,68 +670,104 @@ def acquire(self, mode=None, samples_per_record=None,
 
         for k in range(allocated_buffers):
             try:
-                self.buffer_list.append(Buffer(bps, samples_per_buffer,
-                                               number_of_channels))
+                self.buffer_list.append(Buffer(sample_type, bytes_per_buffer))
             except:
                 self.clear_buffers()
                 raise
 
         # post buffers to Alazar
-        for buf in self.buffer_list:
-            self._call_dll('AlazarPostAsyncBuffer',
-                           self._handle, buf.addr, buf.size_bytes)
-        self.allocated_buffers._set_updated()
-
-        # -----start capture here-----
-        acquisition_controller.pre_start_capture()
-        # call the startcapture method
-        self._call_dll('AlazarStartCapture', self._handle)
-
-        acquisition_controller.pre_acquire()
-        # buffer handling from acquisition
-        buffers_completed = 0
-        buffer_timeout = self.buffer_timeout._get_byte()
-        self.buffer_timeout._set_updated()
-
-        buffer_recycling = (self.buffers_per_acquisition._get_byte() >
-                            self.allocated_buffers._get_byte())
-
-        while buffers_completed < self.buffers_per_acquisition._get_byte():
-            buf = self.buffer_list[buffers_completed % allocated_buffers]
-
-            self._call_dll('AlazarWaitAsyncBufferComplete',
-                           self._handle, buf.addr, buffer_timeout)
-
-            # TODO(damazter) (C) last series of buffers must be handled
-            # exceptionally
-            # (and I want to test the difference) by changing buffer
-            # recycling for the last series of buffers
-
-            # if buffers must be recycled, extract data and repost them
-            # otherwise continue to next buffer
-
-            if buffer_recycling:
-                acquisition_controller.handle_buffer(buf.buffer)
+        try:
+            for buf in self.buffer_list:
                 self._call_dll('AlazarPostAsyncBuffer',
-                               self._handle, buf.addr, buf.size_bytes)
-            buffers_completed += 1
-
-        # stop measurement here
-        self._call_dll('AlazarAbortAsyncRead', self._handle)
-
+                               self._handle, ctypes.cast(buf.addr, ctypes.c_void_p), buf.size_bytes)
+            self.allocated_buffers._set_updated()
+
+            # -----start capture here-----
+            acquisition_controller.pre_start_capture()
+            start = time.clock()  # Keep track of when acquisition started
+            # call the startcapture method
+            self._call_dll('AlazarStartCapture', self._handle)
+
+            acquisition_controller.pre_acquire()
+
+            # buffer handling from acquisition
+            buffers_completed = 0
+            bytes_transferred = 0
+            buffer_timeout = self.buffer_timeout._get_byte()
+            self.buffer_timeout._set_updated()
+
+            buffer_recycling = (self.buffers_per_acquisition._get_byte() >
+                                self.allocated_buffers._get_byte())
+            done_setup = time.clock()
+            while (buffers_completed < self.buffers_per_acquisition._get_byte()):
+                # Wait for the buffer at the head of the list of available
+                # buffers to be filled by the board.
+                buf = self.buffer_list[buffers_completed % allocated_buffers]
+                self._call_dll('AlazarWaitAsyncBufferComplete',
+                               self._handle, ctypes.cast(buf.addr, ctypes.c_void_p), buffer_timeout)
+
+                # TODO(damazter) (C) last series of buffers must be handled
+                # exceptionally
+                # (and I want to test the difference) by changing buffer
+                # recycling for the last series of buffers
+
+                # if buffers must be recycled, extract data and repost them
+                # otherwise continue to next buffer
+                if buffer_recycling:
+                    acquisition_controller.handle_buffer(buf.buffer, buffers_completed)
+                    self._call_dll('AlazarPostAsyncBuffer',
+                                   self._handle, ctypes.cast(buf.addr, ctypes.c_void_p), buf.size_bytes)
+                buffers_completed += 1
+                bytes_transferred += buf.size_bytes
+        finally:
+            # stop measurement here
+            done_capture = time.clock()
+            self._call_dll('AlazarAbortAsyncRead', self._handle)
+        time_done_abort = time.clock()
         # -----cleanup here-----
         # extract data if not yet done
         if not buffer_recycling:
-            for buf in self.buffer_list:
-                acquisition_controller.handle_buffer(buf.buffer)
-
+            for i, buf in enumerate(self.buffer_list):
+                acquisition_controller.handle_buffer(buf.buffer, i)
+        time_done_handling = time.clock()
         # free up memory
         self.clear_buffers()
 
+        time_done_free_mem = time.clock()
         # check if all parameters are up to date
-        for p in self.parameters.values():
-            p.get()
-
+        # Getting IDN is very slow so skip that
+        for name, p in self.parameters.items():
+            if name != 'IDN':
+                p.get()
+
+        # Compute the total transfer time, and display performance information.
+        end_time = time.clock()
+        transfer_time_sec = end_time - start
+        setup_time = done_setup - start
+        capture_time = done_capture - done_setup
+        abort_time = time_done_abort - done_capture
+        handling_time = time_done_handling - time_done_abort
+        free_mem_time = time_done_free_mem - time_done_handling
+        buffers_per_sec = 0
+        bytes_per_sec = 0
+        records_per_sec = 0
+        if transfer_time_sec > 0:
+            buffers_per_sec = buffers_completed / transfer_time_sec
+            bytes_per_sec = bytes_transferred / transfer_time_sec
+            records_per_sec = (records_per_buffer *
+                               buffers_completed / transfer_time_sec)
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug("Captured %d buffers (%f buffers per sec)" %
+                         (buffers_completed, buffers_per_sec))
+            logger.debug("Captured %d records (%f records per sec)" %
+                         (records_per_buffer * buffers_completed, records_per_sec))
+            logger.debug("Transferred {:g} bytes ({:g} "
+                         "bytes per sec)".format(bytes_transferred, bytes_per_sec))
+            logger.debug("Pre capture setup took {}".format(setup_time))
+            logger.debug("Capture took {}".format(capture_time))
+            logger.debug("abort took {}".format(abort_time))
+            logger.debug("handling took {}".format(handling_time))
+            logger.debug("free mem took {}".format(free_mem_time))
         # return result
         return acquisition_controller.post_acquire()
 
@@ -678,18 +795,23 @@ def _call_dll(self, func_name, *args):
         args_out = []
         update_params = []
         for arg in args:
-            if isinstance(arg,AlazarParameter):
+            if isinstance(arg, AlazarParameter):
                 args_out.append(arg._get_byte())
                 update_params.append(arg)
             else:
                 args_out.append(arg)
-
+        # may be useful to log this but is called a lot so leave it out for now
+        # logger.debug("calling dll func {} with args: \n {}".format(func_name, args_out))
         # run the function
         func = getattr(self._ATS_dll, func_name)
-        return_code = func(*args_out)
+        try:
+            return_code = func(*args_out)
+        except Exception as e:
+            logger.error(e)
+            raise
 
         # check for errors
-        if (return_code != self._success) and (return_code !=518):
+        if (return_code != self._success) and (return_code != 518):
             # TODO(damazter) (C) log error
 
             argrepr = repr(args_out)
@@ -714,10 +836,14 @@ def clear_buffers(self):
         This method uncommits all buffers that were committed by the driver.
         This method only has to be called when the acquistion crashes, otherwise
         the driver will uncommit the buffers itself
-        :return: None
+
+        Returns:
+            None
+
         """
         for b in self.buffer_list:
             b.free_mem()
+        logger.info("buffers cleared")
         self.buffer_list = []
 
     def signal_to_volt(self, channel, signal):
@@ -745,11 +871,17 @@ def get_sample_rate(self):
         Returns:
             the number of samples (per channel) per second
         """
-        if self.sample_rate.get() == 'EXTERNAL_CLOCK':
+        if (self.clock_source.get() == 'EXTERNAL_CLOCK_10MHz_REF'
+                and 'external_sample_rate' in self.parameters):
+            rate = self.external_sample_rate.get()
+            # if we are using an external ref clock the sample rate
+            # is set as an integer and not value mapped so we use a different
+            # parameter to represent it
+        elif self.sample_rate.get() == 'EXTERNAL_CLOCK':
             raise Exception('External clock is used, alazar driver '
                             'could not determine sample speed.')
-
-        rate = self.sample_rate.get()
+        else:
+            rate = self.sample_rate.get()
         if rate == '1GHz_REFERENCE_CLOCK':
             rate = 1e9
 
@@ -759,6 +891,37 @@ def get_sample_rate(self):
         else:
             return rate
 
+    @staticmethod
+    def get_num_channels(byte_rep: int) -> int:
+        """
+        Return the number of channels for a specific channel mask
+
+
+        Each single channel is represented by a bitarray with one
+        non zero entry i.e. powers of two. All multichannel masks can be
+        constructed by summing the single channel ones. However, not all
+        configurations are supported. See table 4 Input Channel Configurations
+        on page 241 of the Alazar SDK manual. This contains the complete
+        mapping for all current Alazar cards. It's left to the driver to
+        ensure that only the ones supported for a specific card can be
+        selected
+        """
+        one_channels = tuple(2**i for i in range(16))
+        two_channels = (3, 5, 6, 9, 10, 12)
+        four_channels = (255,)
+        sixteen_channels = (65535,)
+
+        if byte_rep in one_channels:
+            return 1
+        elif byte_rep in two_channels:
+            return 2
+        elif byte_rep in four_channels:
+            return 4
+        elif byte_rep in sixteen_channels:
+            return 16
+        else:
+            raise RuntimeError('Invalid channel configuration supplied')
+
 
 class AlazarParameter(Parameter):
     """
@@ -793,7 +956,7 @@ def __init__(self, name=None, label=None, unit=None, instrument=None,
                 # TODO(damazter) (S) test this validator
                 vals = validators.Enum(*byte_to_value_dict.values())
 
-        super().__init__(name=name, label=label, units=unit, vals=vals,
+        super().__init__(name=name, label=label, unit=unit, vals=vals,
                          instrument=instrument)
         self.instrument = instrument
         self._byte = None
@@ -810,10 +973,13 @@ def __init__(self, name=None, label=None, unit=None, instrument=None,
 
         self._set(value)
 
-    def get(self):
+    def get_raw(self):
         """
         This method returns the name of the value set for this parameter
-        :return: value
+
+        Returns:
+            value
+
         """
         # TODO(damazter) (S) test this exception
         if self._uptodate_flag is False:
@@ -829,7 +995,10 @@ def get(self):
     def _get_byte(self):
         """
         this method gets the byte representation of the value of the parameter
-        :return: byte representation
+
+        Returns:
+            byte representation
+
         """
         return self._byte
 
@@ -838,8 +1007,12 @@ def _set(self, value):
         This method sets the value of this parameter
         This method is private to ensure that all values in the instruments
         are up to date always
-        :param value: the new value (e.g. 'NPT', 0.5, ...)
-        :return: None
+
+        Args:
+            value: the new value (e.g. 'NPT', 0.5, ...)
+        Returns:
+            None
+
         """
 
         # TODO(damazter) (S) test this validation
@@ -856,67 +1029,78 @@ def _set_updated(self):
         can go wrong.
 
         Do not use this function if you do not know what you are doing
-        :return: None
+
+        Returns:
+            None
         """
         self._uptodate_flag = True
 
 
 class Buffer:
-    """
-    This class represents a single buffer used for the data acquisition
+    """Buffer suitable for DMA transfers.
 
-    Args:
-        bits_per_sample: the number of bits needed to store a sample
-        samples_per_buffer: the number of samples needed per buffer(per channel)
-        number_of_channels: the number of channels that will be stored in the
-            buffer
-    """
-    def __init__(self, bits_per_sample, samples_per_buffer,
-                 number_of_channels):
-        if bits_per_sample != 8:
-            raise Exception("Buffer: only 8 bit per sample supported")
-        if os.name != 'nt':
-            raise Exception("Buffer: only Windows supported at this moment")
-        self._allocated = True
+    AlazarTech digitizers use direct memory access (DMA) to transfer
+    data from digitizers to the computer's main memory. This class
+    abstracts a memory buffer on the host, and ensures that all the
+    requirements for DMA transfers are met.
 
-        # try to allocate memory
-        mem_commit = 0x1000
-        page_readwrite = 0x4
+    Buffer export a 'buffer' member, which is a NumPy array view
+    of the underlying memory buffer
 
-        self.size_bytes = samples_per_buffer * number_of_channels
+    Args:
+        c_sample_type (ctypes type): The datatype of the buffer to create.
+        size_bytes (int): The size of the buffer to allocate, in bytes.
+    """
+    def __init__(self, c_sample_type, size_bytes):
+        self.size_bytes = size_bytes
+
+        npSampleType = {
+            ctypes.c_uint8: np.uint8,
+            ctypes.c_uint16: np.uint16,
+            ctypes.c_uint32: np.uint32,
+            ctypes.c_int32: np.int32,
+            ctypes.c_float: np.float32
+        }.get(c_sample_type, 0)
+
+        bytes_per_sample = {
+            ctypes.c_uint8:  1,
+            ctypes.c_uint16: 2,
+            ctypes.c_uint32: 4,
+            ctypes.c_int32:  4,
+            ctypes.c_float:  4
+        }.get(c_sample_type, 0)
 
-        # for documentation please see:
-        # https://msdn.microsoft.com/en-us/library/windows/desktop/aa366887(v=vs.85).aspx
-        ctypes.windll.kernel32.VirtualAlloc.argtypes = [
-            ctypes.c_void_p, ctypes.c_long, ctypes.c_long, ctypes.c_long]
-        ctypes.windll.kernel32.VirtualAlloc.restype = ctypes.c_void_p
-        self.addr = ctypes.windll.kernel32.VirtualAlloc(
-            0, ctypes.c_long(self.size_bytes), mem_commit, page_readwrite)
-        if self.addr is None:
+        self._allocated = True
+        self.addr = None
+        if os.name == 'nt':
+            MEM_COMMIT = 0x1000
+            PAGE_READWRITE = 0x4
+            ctypes.windll.kernel32.VirtualAlloc.restype = ctypes.c_void_p
+            self.addr = ctypes.windll.kernel32.VirtualAlloc(
+                0, ctypes.c_long(size_bytes), MEM_COMMIT, PAGE_READWRITE)
+        else:
             self._allocated = False
-            e = ctypes.windll.kernel32.GetLastError()
-            raise Exception("Memory allocation error: " + str(e))
+            raise Exception("Unsupported OS")
 
-        ctypes_array = (ctypes.c_uint8 *
-                        self.size_bytes).from_address(self.addr)
-        self.buffer = np.frombuffer(ctypes_array, dtype=np.uint8)
+        ctypes_array = (c_sample_type *
+                        (size_bytes // bytes_per_sample)).from_address(self.addr)
+        self.buffer = np.frombuffer(ctypes_array, dtype=npSampleType)
+        self.ctypes_buffer = ctypes_array
         pointer, read_only_flag = self.buffer.__array_interface__['data']
 
     def free_mem(self):
         """
         uncommit memory allocated with this buffer object
-        :return: None
         """
-        mem_release = 0x8000
-
-        # for documentation please see:
-        # https://msdn.microsoft.com/en-us/library/windows/desktop/aa366892(v=vs.85).aspx
-        ctypes.windll.kernel32.VirtualFree.argtypes = [
-            ctypes.c_void_p, ctypes.c_long, ctypes.c_long]
-        ctypes.windll.kernel32.VirtualFree.restype = ctypes.c_int
-        ctypes.windll.kernel32.VirtualFree(ctypes.c_void_p(self.addr), 0,
-                                           mem_release)
+
         self._allocated = False
+        if os.name == 'nt':
+            MEM_RELEASE = 0x8000
+            ctypes.windll.kernel32.VirtualFree.restype = ctypes.c_int
+            ctypes.windll.kernel32.VirtualFree(ctypes.c_void_p(self.addr), 0, MEM_RELEASE)
+        else:
+            self._allocated = True
+            raise Exception("Unsupported OS")
 
     def __del__(self):
         """
@@ -924,11 +1108,10 @@ def __del__(self):
         is the last chance to uncommit the memory to prevent a memory leak.
         This method is not very reliable so users should not rely on this
         functionality
-        :return:
         """
         if self._allocated:
             self.free_mem()
-            logging.warning(
+            logger.warning(
                 'Buffer prevented memory leak; Memory released to Windows.\n'
                 'Memory should have been released before buffer was deleted.')
 
@@ -941,24 +1124,24 @@ class AcquisitionController(Instrument):
 
     The basic structure of an acquisition is:
 
-        - call to AlazarTech_ATS.acquire internal configuration
-        - call to acquisitioncontroller.pre_start_capture
+        - Call to AlazarTech_ATS.acquire internal configuration
+        - Call to acquisitioncontroller.pre_start_capture
         - Call to the start capture of the Alazar board
-        - call to acquisitioncontroller.pre_acquire
-        - loop over all buffers that need to be acquired
+        - Call to acquisitioncontroller.pre_acquire
+        - Loop over all buffers that need to be acquired
           dump each buffer to acquisitioncontroller.handle_buffer
           (only if buffers need to be recycled to finish the acquisiton)
-        - dump remaining buffers to acquisitioncontroller.handle_buffer
+        - Dump remaining buffers to acquisitioncontroller.handle_buffer
           alazar internals
-        - return acquisitioncontroller.post_acquire
+        - Return acquisitioncontroller.post_acquire
 
     Attributes:
         _alazar: a reference to the alazar instrument driver
     """
     def __init__(self, name, alazar_name, **kwargs):
         """
-        :param alazar_name: The name of the alazar instrument on the server
-        :return: nothing
+        Args:
+            alazar_name: The name of the alazar instrument on the server
         """
         super().__init__(name, **kwargs)
         self._alazar = self.find_instrument(alazar_name,
@@ -988,13 +1171,14 @@ def pre_acquire(self):
         raise NotImplementedError(
             'This method should be implemented in a subclass')
 
-    def handle_buffer(self, buffer):
+    def handle_buffer(self, buffer, buffer_number=None):
         """
         This method should store or process the information that is contained
         in the buffers obtained during the acquisition.
 
         Args:
             buffer: np.array with the data from the Alazar card
+            buffer_number: counter for which buffer we are handling
 
         Returns:
             something, it is ignored in any case
diff --git a/qcodes/instrument_drivers/AlazarTech/ATS9360.py b/qcodes/instrument_drivers/AlazarTech/ATS9360.py
new file mode 100644
index 000000000000..9e10e719db95
--- /dev/null
+++ b/qcodes/instrument_drivers/AlazarTech/ATS9360.py
@@ -0,0 +1,308 @@
+from .ATS import AlazarTech_ATS, AlazarParameter
+from qcodes.utils import validators
+
+
+class AlazarTech_ATS9360(AlazarTech_ATS):
+    """
+    This class is the driver for the ATS9360 board
+    it inherits from the ATS base class
+
+    TODO(nataliejpg):
+        -  add clock source options and sample rate options
+           (problem being that byte_to_value_dict of
+           sample_rate relies on value of clock_source)
+
+    """
+    samples_divisor = 128
+
+    def __init__(self, name, **kwargs):
+        dll_path = 'C:\\WINDOWS\\System32\\ATSApi.dll'
+        super().__init__(name, dll_path=dll_path, **kwargs)
+
+        # add parameters
+
+        # ----- Parameters for the configuration of the board -----
+        self.add_parameter(name='clock_source',
+                           parameter_class=AlazarParameter,
+                           label='Clock Source',
+                           unit=None,
+                           value='INTERNAL_CLOCK',
+                           byte_to_value_dict={1: 'INTERNAL_CLOCK',
+                                               2: 'FAST_EXTERNAL_CLOCK',
+                                               7: 'EXTERNAL_CLOCK_10MHz_REF'})
+        self.add_parameter(name='external_sample_rate',
+                           parameter_class=AlazarParameter,
+                           label='External Sample Rate',
+                           unit='S/s',
+                           vals=validators.Ints(300000000, 1800000000),
+                           value=500000000)
+        self.add_parameter(name='sample_rate',
+                           parameter_class=AlazarParameter,
+                           label='Internal Sample Rate',
+                           unit='S/s',
+                           value=500000000,
+                           byte_to_value_dict={0x00000001: 1000,
+                                               0x00000002: 2000,
+                                               0x00000004: 5000,
+                                               0x00000008: 10000,
+                                               0x0000000A: 20000,
+                                               0x0000000C: 50000,
+                                               0x0000000E: 100000,
+                                               0x00000010: 200000,
+                                               0x00000012: 500000,
+                                               0x00000014: 1000000,
+                                               0x00000018: 2000000,
+                                               0x0000001A: 5000000,
+                                               0x0000001C: 10000000,
+                                               0x0000001E: 20000000,
+                                               0x00000021: 25000000,
+                                               0x00000022: 50000000,
+                                               0x00000024: 100000000,
+                                               0x00000025: 125000000,
+                                               0x00000026: 160000000,
+                                               0x00000027: 180000000,
+                                               0x00000028: 200000000,
+                                               0x0000002B: 250000000,
+                                               0x00000030: 500000000,
+                                               0x00000032: 800000000,
+                                               0x00000035: 1000000000,
+                                               0x00000037: 1200000000,
+                                               0x0000003A: 1500000000,
+                                               0x0000003D: 1800000000,
+                                               0x0000003F: 2000000000,
+                                               0x0000006A: 2400000000,
+                                               0x00000075: 3000000000,
+                                               0x0000007B: 3600000000,
+                                               0x00000080: 4000000000,
+                                               0x00000040: 'EXTERNAL_CLOCK',
+                                               })
+        self.add_parameter(name='clock_edge',
+                           parameter_class=AlazarParameter,
+                           label='Clock Edge',
+                           unit=None,
+                           value='CLOCK_EDGE_RISING',
+                           byte_to_value_dict={0: 'CLOCK_EDGE_RISING',
+                                               1: 'CLOCK_EDGE_FALLING'})
+        self.add_parameter(name='decimation',
+                           parameter_class=AlazarParameter,
+                           label='Decimation',
+                           unit=None,
+                           value=1,
+                           vals=validators.Ints(0, 100000))
+
+        for i in ['1', '2']:
+            self.add_parameter(name='coupling' + i,
+                               parameter_class=AlazarParameter,
+                               label='Coupling channel ' + i,
+                               unit=None,
+                               value='DC',
+                               byte_to_value_dict={1: 'AC', 2: 'DC'})
+            self.add_parameter(name='channel_range' + i,
+                               parameter_class=AlazarParameter,
+                               label='Range channel ' + i,
+                               unit='V',
+                               value=0.4,
+                               byte_to_value_dict={7: 0.4})
+            self.add_parameter(name='impedance' + i,
+                               parameter_class=AlazarParameter,
+                               label='Impedance channel ' + i,
+                               unit='Ohm',
+                               value=50,
+                               byte_to_value_dict={2: 50})
+
+        self.add_parameter(name='trigger_operation',
+                           parameter_class=AlazarParameter,
+                           label='Trigger Operation',
+                           unit=None,
+                           value='TRIG_ENGINE_OP_J',
+                           byte_to_value_dict={
+                               0: 'TRIG_ENGINE_OP_J',
+                               1: 'TRIG_ENGINE_OP_K',
+                               2: 'TRIG_ENGINE_OP_J_OR_K',
+                               3: 'TRIG_ENGINE_OP_J_AND_K',
+                               4: 'TRIG_ENGINE_OP_J_XOR_K',
+                               5: 'TRIG_ENGINE_OP_J_AND_NOT_K',
+                               6: 'TRIG_ENGINE_OP_NOT_J_AND_K'})
+        for i in ['1', '2']:
+            self.add_parameter(name='trigger_engine' + i,
+                               parameter_class=AlazarParameter,
+                               label='Trigger Engine ' + i,
+                               unit=None,
+                               value='TRIG_ENGINE_' + ('J' if i == 0 else 'K'),
+                               byte_to_value_dict={0: 'TRIG_ENGINE_J',
+                                                   1: 'TRIG_ENGINE_K'})
+            self.add_parameter(name='trigger_source' + i,
+                               parameter_class=AlazarParameter,
+                               label='Trigger Source ' + i,
+                               unit=None,
+                               value='EXTERNAL',
+                               byte_to_value_dict={0: 'CHANNEL_A',
+                                                   1: 'CHANNEL_B',
+                                                   2: 'EXTERNAL',
+                                                   3: 'DISABLE'})
+            self.add_parameter(name='trigger_slope' + i,
+                               parameter_class=AlazarParameter,
+                               label='Trigger Slope ' + i,
+                               unit=None,
+                               value='TRIG_SLOPE_POSITIVE',
+                               byte_to_value_dict={1: 'TRIG_SLOPE_POSITIVE',
+                                                   2: 'TRIG_SLOPE_NEGATIVE'})
+            self.add_parameter(name='trigger_level' + i,
+                               parameter_class=AlazarParameter,
+                               label='Trigger Level ' + i,
+                               unit=None,
+                               value=140,
+                               vals=validators.Ints(0, 255))
+
+        self.add_parameter(name='external_trigger_coupling',
+                           parameter_class=AlazarParameter,
+                           label='External Trigger Coupling',
+                           unit=None,
+                           value='DC',
+                           byte_to_value_dict={1: 'AC', 2: 'DC'})
+        self.add_parameter(name='external_trigger_range',
+                           parameter_class=AlazarParameter,
+                           label='External Trigger Range',
+                           unit=None,
+                           value='ETR_2V5',
+                           byte_to_value_dict={0: 'ETR_5V', 1: 'ETR_1V',
+                                               2: 'ETR_TTL', 3: 'ETR_2V5'})
+        self.add_parameter(name='trigger_delay',
+                           parameter_class=AlazarParameter,
+                           label='Trigger Delay',
+                           unit='Sample clock cycles',
+                           value=0,
+                           vals=validators.Ints(min_value=0))
+
+        # NOTE: The board will wait for a for this amount of time for a
+        # trigger event.  If a trigger event does not arrive, then the
+        # board will automatically trigger. Set the trigger timeout value
+        # to 0 to force the board to wait forever for a trigger event.
+        #
+        # IMPORTANT: The trigger timeout value should be set to zero after
+        # appropriate trigger parameters have been determined, otherwise
+        # the board may trigger if the timeout interval expires before a
+        # hardware trigger event arrives.
+        self.add_parameter(name='timeout_ticks',
+                           parameter_class=AlazarParameter,
+                           label='Timeout Ticks',
+                           unit='10 us',
+                           value=0,
+                           vals=validators.Ints(min_value=0))
+
+        self.add_parameter(name='aux_io_mode',
+                           parameter_class=AlazarParameter,
+                           label='AUX I/O Mode',
+                           unit=None,
+                           value='AUX_IN_AUXILIARY',
+                           byte_to_value_dict={0: 'AUX_OUT_TRIGGER',
+                                               1: 'AUX_IN_TRIGGER_ENABLE',
+                                               13: 'AUX_IN_AUXILIARY'})
+
+        self.add_parameter(name='aux_io_param',
+                           parameter_class=AlazarParameter,
+                           label='AUX I/O Param',
+                           unit=None,
+                           value='NONE',
+                           byte_to_value_dict={0: 'NONE',
+                                               1: 'TRIG_SLOPE_POSITIVE',
+                                               2: 'TRIG_SLOPE_NEGATIVE'})
+
+        # ----- Parameters for the acquire function -----
+        self.add_parameter(name='mode',
+                           parameter_class=AlazarParameter,
+                           label='Acquisition mode',
+                           unit=None,
+                           value='NPT',
+                           byte_to_value_dict={0x200: 'NPT', 0x400: 'TS'})
+        self.add_parameter(name='samples_per_record',
+                           parameter_class=AlazarParameter,
+                           label='Samples per Record',
+                           unit=None,
+                           value=1024,
+                           vals=validators.Multiples(
+                                divisor=self.samples_divisor, min_value=256))
+        self.add_parameter(name='records_per_buffer',
+                           parameter_class=AlazarParameter,
+                           label='Records per Buffer',
+                           unit=None,
+                           value=10,
+                           vals=validators.Ints(min_value=0))
+        self.add_parameter(name='buffers_per_acquisition',
+                           parameter_class=AlazarParameter,
+                           label='Buffers per Acquisition',
+                           unit=None,
+                           value=10,
+                           vals=validators.Ints(min_value=0))
+        self.add_parameter(name='channel_selection',
+                           parameter_class=AlazarParameter,
+                           label='Channel Selection',
+                           unit=None,
+                           value='AB',
+                           byte_to_value_dict={1: 'A', 2: 'B', 3: 'AB'})
+        self.add_parameter(name='transfer_offset',
+                           parameter_class=AlazarParameter,
+                           label='Transfer Offset',
+                           unit='Samples',
+                           value=0,
+                           vals=validators.Ints(min_value=0))
+        self.add_parameter(name='external_startcapture',
+                           parameter_class=AlazarParameter,
+                           label='External Startcapture',
+                           unit=None,
+                           value='ENABLED',
+                           byte_to_value_dict={0x0: 'DISABLED',
+                                               0x1: 'ENABLED'})
+        self.add_parameter(name='enable_record_headers',
+                           parameter_class=AlazarParameter,
+                           label='Enable Record Headers',
+                           unit=None,
+                           value='DISABLED',
+                           byte_to_value_dict={0x0: 'DISABLED',
+                                               0x8: 'ENABLED'})
+        self.add_parameter(name='alloc_buffers',
+                           parameter_class=AlazarParameter,
+                           label='Alloc Buffers',
+                           unit=None,
+                           value='DISABLED',
+                           byte_to_value_dict={0x0: 'DISABLED',
+                                               0x20: 'ENABLED'})
+        self.add_parameter(name='fifo_only_streaming',
+                           parameter_class=AlazarParameter,
+                           label='Fifo Only Streaming',
+                           unit=None,
+                           value='DISABLED',
+                           byte_to_value_dict={0x0: 'DISABLED',
+                                               0x800: 'ENABLED'})
+        self.add_parameter(name='interleave_samples',
+                           parameter_class=AlazarParameter,
+                           label='Interleave Samples',
+                           unit=None,
+                           value='DISABLED',
+                           byte_to_value_dict={0x0: 'DISABLED',
+                                               0x1000: 'ENABLED'})
+        self.add_parameter(name='get_processed_data',
+                           parameter_class=AlazarParameter,
+                           label='Get Processed Data',
+                           unit=None,
+                           value='DISABLED',
+                           byte_to_value_dict={0x0: 'DISABLED',
+                                               0x2000: 'ENABLED'})
+        self.add_parameter(name='allocated_buffers',
+                           parameter_class=AlazarParameter,
+                           label='Allocated Buffers',
+                           unit=None,
+                           value=4,
+                           vals=validators.Ints(min_value=0))
+
+        self.add_parameter(name='buffer_timeout',
+                           parameter_class=AlazarParameter,
+                           label='Buffer Timeout',
+                           unit='ms',
+                           value=1000,
+                           vals=validators.Ints(min_value=0))
+
+        model = self.get_idn()['model']
+        if model != 'ATS9360':
+            raise Exception("The Alazar board kind is not 'ATS9360',"
+                            " found '" + str(model) + "' instead.")
diff --git a/qcodes/instrument_drivers/AlazarTech/ATS9870.py b/qcodes/instrument_drivers/AlazarTech/ATS9870.py
index eebda1985496..e8a2a11a9c39 100644
--- a/qcodes/instrument_drivers/AlazarTech/ATS9870.py
+++ b/qcodes/instrument_drivers/AlazarTech/ATS9870.py
@@ -7,7 +7,7 @@ class AlazarTech_ATS9870(AlazarTech_ATS):
     This class is the driver for the ATS9870 board
     it inherits from the ATS base class
 
-    it creates all necessary parameters for the Alazar card
+    It creates all necessary parameters for the Alazar card
     """
     def __init__(self, name, **kwargs):
         dll_path = 'C:\\WINDOWS\\System32\\ATSApi.dll'
@@ -150,6 +150,24 @@ def __init__(self, name, **kwargs):
                            unit='10 us',
                            value=0,
                            vals=validators.Ints(min_value=0))
+        self.add_parameter(name='aux_io_mode',
+                           parameter_class=AlazarParameter,
+                           label='AUX I/O Mode',
+                           unit=None,
+                           value='AUX_IN_AUXILIARY',
+                           byte_to_value_dict={0: 'AUX_OUT_TRIGGER',
+                                               1: 'AUX_IN_TRIGGER_ENABLE',
+                                               13: 'AUX_IN_AUXILIARY'})
+
+        self.add_parameter(name='aux_io_param',
+                           parameter_class=AlazarParameter,
+                           label='AUX I/O Param',
+                           unit=None,
+                           value='NONE',
+                           byte_to_value_dict={0: 'NONE',
+                                               1: 'TRIG_SLOPE_POSITIVE',
+                                               2: 'TRIG_SLOPE_NEGATIVE'})
+
 
         # ----- Parameters for the acquire function -----
         self.add_parameter(name='mode',
@@ -263,4 +281,4 @@ def __init__(self, name, **kwargs):
         model = self.get_idn()['model']
         if model != 'ATS9870':
             raise Exception("The Alazar board kind is not 'ATS9870',"
-                            " found '" + str(model) + "' instead.")
\ No newline at end of file
+                            " found '" + str(model) + "' instead.")
diff --git a/qcodes/instrument_drivers/AlazarTech/ATS_acquisition_controllers.py b/qcodes/instrument_drivers/AlazarTech/ATS_acquisition_controllers.py
index a90269a85030..69d1affa0991 100644
--- a/qcodes/instrument_drivers/AlazarTech/ATS_acquisition_controllers.py
+++ b/qcodes/instrument_drivers/AlazarTech/ATS_acquisition_controllers.py
@@ -88,7 +88,7 @@ def pre_acquire(self):
         # Alazar card starts listening for a trigger pulse
         pass
 
-    def handle_buffer(self, data):
+    def handle_buffer(self, data, buffer_number=None):
         """
         See AcquisitionController
         :return: