auto-acquisition-4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python PLI data acquisition\n",
    "\n",
    "env: py39"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import serial\n",
    "import serial.tools.list_ports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "ports = serial.tools.list_ports.comports()\n",
    "arduino_port = None\n",
    "ser = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/dev/cu.Bluetooth-Incoming-Port: n/a [n/a]\n",
      "/dev/cu.NT-P58C: n/a [n/a]\n",
      "/dev/cu.usbmodem101: IOUSBHostDevice [USB VID:PID=2341:0043 SER=85935333337351E07262 LOCATION=0-1]\n"
     ]
    }
   ],
   "source": [
    "for port, desc, hwid in sorted(ports):\n",
    "    print(\"{}: {} [{}]\".format(port, desc, hwid))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/dev/cu.Bluetooth-Incoming-Port: n/a [n/a]\n",
      "/dev/cu.NT-P58C: n/a [n/a]\n",
      "/dev/cu.usbmodem101: IOUSBHostDevice [USB VID:PID=2341:0043 SER=85935333337351E07262 LOCATION=0-1]\n",
      "arduino_port: /dev/cu.usbmodem101\n"
     ]
    }
   ],
   "source": [
    "for port, desc, hwid in sorted(ports):\n",
    "    print(\"{}: {} [{}]\".format(port, desc, hwid))\n",
    "    if \"usbmodem\" in port or \"usbserial\" in port:\n",
    "        arduino_port = port\n",
    "        print(f\"arduino_port: {arduino_port}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this produces a double flash when it's ok\n",
    "ser = serial.Serial(arduino_port, 9600)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 296,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# rotate polariser\n",
    "step = 50000\n",
    "str = f\"3+{step}\"\n",
    "ser.write(bytes(str, \"ascii\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 292,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# +Y: Into PLI (up in the slice)\n",
    "step = 50\n",
    "str = f\"\"\"1+{step}\n",
    "2-{step}\"\"\"\n",
    "ser.write(bytes(str, \"ascii\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 301,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# -Y: Away from PLI (down in the slice)\n",
    "step = 13000\n",
    "str = f\"\"\"1-{step}\n",
    "2+{step}\"\"\"\n",
    "ser.write(bytes(str, \"ascii\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 291,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# +X: toward the polariser's stepper (right in the slice)\n",
    "step = 50 \n",
    "str = f\"\"\"1+{step}\n",
    "2+{step}\"\"\"\n",
    "ser.write(bytes(str, \"ascii\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 282,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# -X: away from the polariser's stepper (left in the slice)\n",
    "step = 150\n",
    "str = f\"\"\"1-{step}\n",
    "2-{step}\"\"\"\n",
    "ser.write(bytes(str, \"ascii\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# illumination on\n",
    "str = \"dir 4+\"\n",
    "ser.write(bytes(str, \"ascii\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# illumination off\n",
    "str = \"dir 4-\"\n",
    "ser.write(bytes(str, \"ascii\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'1-123\\n2-123'\n",
      "b'1+456\\n2-456'\n"
     ]
    }
   ],
   "source": [
    "dx, dy = -123, 456\n",
    "\n",
    "# +X: toward the polariser's stepper (right in the slice image)\n",
    "sign = \"+\" if dx >= 0 else \"\"\n",
    "str = f\"\"\"1{sign}{dx}\\n2{sign}{dx}\"\"\"\n",
    "print(bytes(str, \"ascii\"))\n",
    "\n",
    "# +Y: Into PLI (up in the slice image)\n",
    "signx, signy = (\"+\", \"-\") if dy >= 0 else (\"-\", \"+\")\n",
    "str = f\"\"\"1{signx}{abs(dy)}\\n2{signy}{abs(dy)}\"\"\"\n",
    "print(bytes(str, \"ascii\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "ser.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Acquisition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/dev/cu.Bluetooth-Incoming-Port: n/a [n/a]\n",
      "/dev/cu.NT-P58C: n/a [n/a]\n",
      "/dev/cu.usbmodem1101: IOUSBHostDevice [USB VID:PID=2341:0043 SER=85935333337351E07262 LOCATION=1-1]\n",
      "/dev/cu.Bluetooth-Incoming-Port: n/a [n/a]\n",
      "/dev/cu.NT-P58C: n/a [n/a]\n",
      "/dev/cu.usbmodem1101: IOUSBHostDevice [USB VID:PID=2341:0043 SER=85935333337351E07262 LOCATION=1-1]\n",
      "arduino_port: /dev/cu.usbmodem1101\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import serial\n",
    "import serial.tools.list_ports\n",
    "\n",
    "ports = serial.tools.list_ports.comports()\n",
    "arduino_port = None\n",
    "ser = None\n",
    "\n",
    "for port, desc, hwid in sorted(ports):\n",
    "    print(\"{}: {} [{}]\".format(port, desc, hwid))\n",
    "\n",
    "for port, desc, hwid in sorted(ports):\n",
    "    print(\"{}: {} [{}]\".format(port, desc, hwid))\n",
    "    if \"usbmodem\" in port or \"usbserial\" in port:\n",
    "        arduino_port = port\n",
    "        print(f\"arduino_port: {arduino_port}\")\n",
    "\n",
    "# this produces a double flash when it's ok\n",
    "ser = serial.Serial(arduino_port, 9600)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First, place the sample at the origin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "fovstep = 500\n",
    "ncols = 2\n",
    "nrows = 2\n",
    "n_angles = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sleep():\n",
    "    time.sleep(0.5)\n",
    "def illumination_on():\n",
    "    str = \"dir 4+\"\n",
    "    ser.write(bytes(str, \"ascii\"))\n",
    "    sleep()\n",
    "def illumination_off():\n",
    "    str = \"dir 4-\"\n",
    "    ser.write(bytes(str, \"ascii\"))\n",
    "    sleep()\n",
    "def rotate_pos(angle):\n",
    "    str = f\"3+{angle}\"\n",
    "    ser.write(bytes(str, \"ascii\"))\n",
    "    sleep()\n",
    "def rotate_neg(angle):\n",
    "    str = f\"3-{angle}\"\n",
    "    ser.write(bytes(str, \"ascii\"))\n",
    "    sleep()\n",
    "def move_pos_x(x):\n",
    "    str = f\"\"\"1-{x}\n",
    "2-{x}\"\"\"\n",
    "    ser.write(bytes(str, \"ascii\"))\n",
    "    sleep()\n",
    "def move_neg_x(x):\n",
    "    str = f\"\"\"1+{x}\n",
    "2+{x}\"\"\"\n",
    "    ser.write(bytes(str, \"ascii\"))\n",
    "    sleep()\n",
    "def move_pos_y(y):\n",
    "    str = f\"\"\"1+{y}\n",
    "2-{y}\"\"\"\n",
    "    ser.write(bytes(str, \"ascii\"))\n",
    "    sleep()\n",
    "def move_neg_y(y):\n",
    "    str = f\"\"\"1-{y}\n",
    "2+{y}\"\"\"\n",
    "    ser.write(bytes(str, \"ascii\"))\n",
    "    sleep()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Acquiring 0, 0, 0\n",
      "Acquiring 0, 0, 1\n",
      "Acquiring 0, 0, 2\n",
      "Acquiring 0, 0, 3\n",
      "Acquiring 0, 0, 4\n",
      "Acquiring 0, 1, 0\n",
      "Acquiring 0, 1, 1\n",
      "Acquiring 0, 1, 2\n",
      "Acquiring 0, 1, 3\n",
      "Acquiring 0, 1, 4\n",
      "Acquiring 1, 0, 0\n",
      "Acquiring 1, 0, 1\n",
      "Acquiring 1, 0, 2\n",
      "Acquiring 1, 0, 3\n",
      "Acquiring 1, 0, 4\n",
      "Acquiring 1, 1, 0\n",
      "Acquiring 1, 1, 1\n",
      "Acquiring 1, 1, 2\n",
      "Acquiring 1, 1, 3\n",
      "Acquiring 1, 1, 4\n"
     ]
    }
   ],
   "source": [
    "# Acquire a grid of FOVs\n",
    "\n",
    "fov_x_steps, fov_y_steps = 500, 300\n",
    "angle_steps = 500\n",
    "nx = 2\n",
    "ny = 2\n",
    "n_angles = 5\n",
    "\n",
    "for i in range(ny):\n",
    "    for j in range(nx):\n",
    "\n",
    "        # acquire\n",
    "        for k in range(n_angles):\n",
    "            illumination_on()\n",
    "\n",
    "            # acquire\n",
    "            print(f\"Acquiring y:{i}, x:{j}, angle:{k}\")\n",
    "            time.sleep(1)\n",
    "\n",
    "            # turn off illumination\n",
    "            illumination_off()\n",
    "\n",
    "            # rotate polariser\n",
    "            rotate_pos(angle_steps)\n",
    "        # return polariser to origin\n",
    "        rotate_neg(n_angles * angle_steps)\n",
    "        \n",
    "        # move to next position\n",
    "        if j < nx - 1:\n",
    "            move_pos_x(fov_x_steps)\n",
    "        else:\n",
    "            move_neg_x(fov_x_steps * (nx - 1))\n",
    "            move_neg_y(fov_y_steps)\n",
    "move_neg_x(fov_x_steps * (nx - 1))\n",
    "move_pos_y(fov_y_steps * (ny - 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "ser.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test `asyncio`\n",
    "Waiting fixed durations makes everything slow. It'd be better to listen to the\n",
    "messages sent by the machine through the serial interface to determine when\n",
    "it's done.\n",
    "Here I test the use of `asyncio` within a jupyter notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "world\n"
     ]
    }
   ],
   "source": [
    "import asyncio\n",
    "async def fn():\n",
    "  print('hello')\n",
    "  await asyncio.sleep(1)\n",
    "  print('world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "world\n"
     ]
    }
   ],
   "source": [
    "await fn()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code simulates a lengthy task (the pli machine): `do_things()`. The `status` variable tracks the status of the task. The `wait_for_done()` function can be awaited and will return when `do_things` is done."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "status = 'idle'\n",
    "async def do_things():\n",
    "    global status\n",
    "    print(\"doing many things\")\n",
    "    status = 'busy'\n",
    "    for i in range(10):\n",
    "        status = f\"i: {i}\"\n",
    "        await asyncio.sleep(0.5)\n",
    "    status = 'done'\n",
    "\n",
    "async def wait_for_done():\n",
    "    global status\n",
    "    while status != 'done':\n",
    "        await asyncio.sleep(1)\n",
    "    print(\"done waiting\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "doing many things\n"
     ]
    }
   ],
   "source": [
    "await do_things()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "begin\n",
      "doing many things\n",
      "done waiting\n",
      "end\n"
     ]
    }
   ],
   "source": [
    "print('begin')\n",
    "\n",
    "# this triggers the lengthy task\n",
    "task = asyncio.create_task(do_things())\n",
    "await task\n",
    "\n",
    "# this monitors the status and returns when the task is done\n",
    "await wait_for_done()\n",
    "\n",
    "print('end')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py39",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}