USB-201-Demo.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0672b36a-2b7f-4bf6-8c47-e63384e6d320",
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import absolute_import, division, print_function\n",
    "\n",
    "from IPython.display import display as display\n",
    "from IPython.display import Markdown as markdown\n",
    "import random as rd\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pylab as plt\n",
    "import time as t\n",
    "\n",
    "\n",
    "#Measurement Computing mcculw imports\n",
    "from mcculw import ul\n",
    "from mcculw.enums import (FunctionType, ScanOptions, ULRange, InterfaceType)\n",
    "from ctypes import cast, POINTER, c_double, c_ushort, c_ulong\n",
    "from mcculw.ul import ULError\n",
    "from mcculw.enums import InterfaceType\n",
    "from mcculw.enums import ULRange\n",
    "from mcculw.enums import AnalogInputMode\n",
    "\n",
    "\n",
    "# USB-201 demonstation class\n",
    "class daq:\n",
    "\n",
    "\n",
    "    @classmethod \n",
    "    def __init__(self, device_name = \"USB-201\", rate = 100, samples=100):\n",
    "        self.board_name = device_name\n",
    "        self.points_per_channel = samples\n",
    "        self.sample_rate = rate\n",
    "        self.num_chans = 4\n",
    "        self.max_length = 2000\n",
    "        self.total_count = 1\n",
    "        self.board_number = -1\n",
    "        self.memhandle = 0\n",
    "        self.temp = np.zeros((1,4))\n",
    "        self.arr = np.zeros((self.max_length, self.num_chans))\n",
    "        self.device = 0\n",
    "        self.open_device(self)\n",
    "\n",
    "        \n",
    "    @classmethod \n",
    "    def __del__(self):\n",
    "        self.close_device(self)\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"{self.board_name}\"\n",
    "\n",
    "    def _create_array(self):\n",
    "        np.resize(self.arr, (self.points_per_channel, self.num_chans))\n",
    "        self.arr.fill(0)\n",
    "        return self.arr\n",
    "\n",
    "\n",
    "    def set_sample_rate(self, sample_rate=100):\n",
    "        if int(sample_rate * self.num_chans) > 100000:\n",
    "            display(markdown(f\"Sample rate too high, the maximum is 25,000 Hz. Reset to 100 Hz\"))\n",
    "            self.sample_rate = 100\n",
    "        else:\n",
    "            self.sample_rate = sample_rate\n",
    "            display(markdown(f\"Sample rate changed to {self.sample_rate} Hz\"))\n",
    "        return self.sample_rate\n",
    "\n",
    "\n",
    "\n",
    "    def set_samples_per_channel(self, number_of_samples=333):\n",
    "        if int(number_of_samples) > self.max_length:\n",
    "            display(markdown(f\"Requested samples per channel {number_of_samples} is greater than {self.max_length}, reset to 1000\"))\n",
    "            self.points_per_channel = 1000\n",
    "        else:\n",
    "            self.points_per_channel = number_of_samples\n",
    "            display(markdown(f\"Samples per channel changed to {self.points_per_channel}\"))\n",
    "        return self.points_per_channel\n",
    "\n",
    "    '''\n",
    "    open_device is executed in __init___\n",
    "\n",
    "    It attempts to find a device by its commercial name. Once found, \n",
    "    it sets the board number, sample rate and number of sameples\n",
    "    per channel\n",
    "    '''\n",
    "\n",
    "    def open_device(self):\n",
    "\n",
    "        board_num = -1\n",
    "        board_index = 0\n",
    "        board_num = -1\n",
    "\n",
    "        ul.ignore_instacal()\n",
    "\n",
    "        dev_list = ul.get_daq_device_inventory(InterfaceType.USB)\n",
    "        if len(dev_list) > 0:\n",
    "            for device in dev_list:\n",
    "                if str(device) == self.board_name:\n",
    "                    self.device = device\n",
    "                    display(markdown(f\"Found {device} board number = {board_index}\"))\n",
    "                    display(markdown(f\"Serial number: {device.unique_id}\"))\n",
    "                    display(markdown(f\"Product type: {hex(device.product_id)}\"))\n",
    "                    display(markdown(f\"Samples per channel {self.points_per_channel} \"))\n",
    "                    display(markdown(f\"Sample rate is {self.sample_rate} \"))\n",
    "                    self.board_num = board_index\n",
    "                    ul.create_daq_device(self.board_num, device)\n",
    "                    return\n",
    "            if board_num == -1:\n",
    "                display(markdown(f\"Device {self.board_name} not found\"))\n",
    "                \n",
    "        else:\n",
    "            display(markdown(\"No devices detected\"))\n",
    "\n",
    "\n",
    "\n",
    "    '''\n",
    "    This function is call by the destructor:\n",
    "    def __del__(self):\n",
    "        self.close_device(self)\n",
    "    It closes the device and frees the allocated buffer memory\n",
    "    '''\n",
    "\n",
    "    def close_device(self):\n",
    "        if self.memhandle:\n",
    "            # Free the buffer in a finally block to prevent a memory leak.\n",
    "            ul.win_buf_free(self.memhandle)\n",
    "        if self.board_num > -1:\n",
    "            ul.release_daq_device(self.board_num)\n",
    "            display(markdown(f\"{self.board_name} closed...\"))\n",
    "        \n",
    "\n",
    "    '''\n",
    "    plotting routine, requires a 2D array containing four channels\n",
    "    '''\n",
    "\n",
    "    def plot_data(self, arr):\n",
    "\n",
    "        x = np.linspace(start=0, stop=19, num=self.points_per_channel, dtype=np.dtype(np.int16))\n",
    "\n",
    "        ch0 = [row[0] for row in arr]\n",
    "        ch1 = [row[1] for row in arr]\n",
    "        ch2 = [row[2] for row in arr]\n",
    "        ch3 = [row[3] for row in arr]\n",
    "\n",
    "        plt.plot(ch0, 'b', ch1, 'r', ch2, 'g', ch3, 'k')\n",
    "        plt.xlabel('Samples');\n",
    "        plt.ylabel('Volts');\n",
    "        plt.title('Plotting Demonstration')\n",
    "        plt.legend(['Channel 0', 'Channel 1', 'Channel 2', 'Channel 3'])\n",
    "        plt.grid()\n",
    "        plt.show()\n",
    "\n",
    "    '''\n",
    "    get_data() \n",
    "\n",
    "    Determines the total sample count,\n",
    "    which is samples per channel times the \n",
    "    number of channels. \n",
    "\n",
    "    For simplicity, the channels are hard coded to \n",
    "    be 0 - 3\n",
    "\n",
    "    The default buffer is resize to me the user demands\n",
    "\n",
    "    mcculw a_in_scan function is used to grab requested\n",
    "    scans. FOREGROUND scan mode is used,\n",
    "    which blocks the function until all the samples have\n",
    "    been acquired.     \n",
    "    '''\n",
    "\n",
    "    def get_data(self):\n",
    "\n",
    "        memhandle = None\n",
    "\n",
    "        low_chan = 0\n",
    "        high_chan = 3\n",
    "\n",
    "        self.total_count = self.points_per_channel * self.num_chans\n",
    "        self.arr = np.resize(self.arr, (self.points_per_channel, self.num_chans))\n",
    "        self.memhandle = ul.scaled_win_buf_alloc(self.total_count)\n",
    "    \n",
    "        ctypes_array = cast(self.memhandle, POINTER(c_double))\n",
    "\n",
    "        # Check if the buffer was successfully allocated\n",
    "        if not self.memhandle:\n",
    "            raise Exception('Error: Failed to allocate memory')\n",
    "\n",
    "        # Start the scan\n",
    "        e = ul.a_in_scan(self.board_num, low_chan, high_chan, self.total_count,\n",
    "                         self.sample_rate, ULRange.BIP10VOLTS, self.memhandle,\n",
    "                         ScanOptions.FOREGROUND | ScanOptions.SCALEDATA)\n",
    "\n",
    "        display(markdown(\"Scan completed successfully.\"))\n",
    "\n",
    "        data_index = 0\n",
    "        for row in range(self.points_per_channel):\n",
    "            self.temp = self.arr[row]\n",
    "            for chan in range(self.num_chans):\n",
    "                eng_value = ctypes_array[data_index]\n",
    "                self.temp[chan] = eng_value\n",
    "                data_index += 1\n",
    "\n",
    "        return self.arr\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e2405834-ee17-4556-bd66-173c108a5751",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "# Welcome to my USB-201 Demonstration"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Found USB-201 board number = 0"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Serial number: 1FFC8D1"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Product type: 0x113"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Samples per channel 200 "
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Sample rate is 1000 "
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Samples per channel changed to 2000"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Sample rate changed to 2000 Hz"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "Scan completed successfully."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Ch0</th>\n",
       "      <th>Ch1</th>\n",
       "      <th>Ch2</th>\n",
       "      <th>Ch3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-0.001978</td>\n",
       "      <td>1.74919</td>\n",
       "      <td>1.757415</td>\n",
       "      <td>1.753897</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.001978</td>\n",
       "      <td>1.74919</td>\n",
       "      <td>1.757415</td>\n",
       "      <td>1.753897</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.001978</td>\n",
       "      <td>1.74919</td>\n",
       "      <td>1.752309</td>\n",
       "      <td>1.753897</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-0.001978</td>\n",
       "      <td>1.74919</td>\n",
       "      <td>1.757415</td>\n",
       "      <td>1.753897</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-0.001978</td>\n",
       "      <td>1.74919</td>\n",
       "      <td>1.757415</td>\n",
       "      <td>1.753897</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1995</th>\n",
       "      <td>-0.001978</td>\n",
       "      <td>1.74919</td>\n",
       "      <td>1.757415</td>\n",
       "      <td>1.753897</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1996</th>\n",
       "      <td>-0.001978</td>\n",
       "      <td>1.74919</td>\n",
       "      <td>1.757415</td>\n",
       "      <td>1.753897</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1997</th>\n",
       "      <td>-0.001978</td>\n",
       "      <td>1.74919</td>\n",
       "      <td>1.757415</td>\n",
       "      <td>1.753897</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1998</th>\n",
       "      <td>-0.001978</td>\n",
       "      <td>1.74919</td>\n",
       "      <td>1.757415</td>\n",
       "      <td>1.753897</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1999</th>\n",
       "      <td>-0.001978</td>\n",
       "      <td>1.74919</td>\n",
       "      <td>1.757415</td>\n",
       "      <td>1.753897</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2000 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "           Ch0      Ch1       Ch2       Ch3\n",
       "0    -0.001978  1.74919  1.757415  1.753897\n",
       "1    -0.001978  1.74919  1.757415  1.753897\n",
       "2    -0.001978  1.74919  1.752309  1.753897\n",
       "3    -0.001978  1.74919  1.757415  1.753897\n",
       "4    -0.001978  1.74919  1.757415  1.753897\n",
       "...        ...      ...       ...       ...\n",
       "1995 -0.001978  1.74919  1.757415  1.753897\n",
       "1996 -0.001978  1.74919  1.757415  1.753897\n",
       "1997 -0.001978  1.74919  1.757415  1.753897\n",
       "1998 -0.001978  1.74919  1.757415  1.753897\n",
       "1999 -0.001978  1.74919  1.757415  1.753897\n",
       "\n",
       "[2000 rows x 4 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "USB-201 closed..."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(markdown(\"# Welcome to my USB-201 Demonstration\"))\n",
    "\n",
    "mcc = daq(\"USB-201\", rate=1000, samples=200)\n",
    "\n",
    "\n",
    "new_number_of_samples = mcc.set_samples_per_channel(number_of_samples=2000)\n",
    "new_rate = mcc.set_sample_rate(sample_rate = 2000)\n",
    "\n",
    "daq_data = mcc.get_data()\n",
    "mcc.plot_data(daq_data)\n",
    "\n",
    "\n",
    "h=display(display_id=2)\n",
    "df = pd.DataFrame(data=daq_data[0:mcc.points_per_channel], columns=['Ch0','Ch1', 'Ch2','Ch3'])\n",
    "h.update(df)\n",
    "\n",
    "del mcc\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db1f76d0-f512-45ed-9470-e458e132cae6",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}