{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2cf25dc7-1fb4-4066-b292-d089be646f35",
   "metadata": {},
   "source": [
    "# Python 入門講座：EPICS CA  (と　Jupyter Notbook widget) 篇"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c5e78af-a4c4-4fde-a920-38a18a462469",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": [
     "chap1"
    ]
   },
   "source": [
    "# EPICS チャンネル アクセス　(CA)　モジュール(python-ca)\n",
    "\n",
    "この文書では、EPICS の基本プロトコル チャンネル　アクセス（CA）をpythonプログラムの中で利用する一方法を紹介します。ここでは KEK で開発された Pyhon ca モジュールを使います。\n",
    "\n",
    "EPICSは加速器など大小の実験装置をリモート制御するためのソフトウェア フレームワークの一つです。\n",
    "EPICSでは制御のための通信はチャンネルアクセス(CA)と呼ばれるプロトコルが使われます。チャンネルアクセスプロトコルは標準的なIPネットワークを基本としており、さまざまな環境で簡単に利用することができます。\n",
    "\n",
    "チャンネルアクセスプロトコルでは、その名が示す様に、一つのシステムの中で一意の名前をもつチャンネルを基本にプロトコルが構成されています。チャンネルは制御対象の一つの制御情報と関係付けられていて、最新の値(.VAL)の他に、操作の上下限値、警報値、ステータス情報などの補助的な情報を含んでいます。\n",
    "\n",
    "EPICSのチャンネル アクセスをPythonプログラムで取り扱うためのモジュールは、KEK のCAモジュールの他にも、幾つか公表されています。KEK/KEKBで開発された Python ca モジュールおよび　cas モジュールは、長らくKEK/J-PARCで使用されており、EPICS CAをサポートするPython モジュールの中でも歴史あるモジュールの一つです。 次世代EPICSであるEPICS 7では、チャンネルアクセスに加えて、新しいネットワークプロトコル、PVアクセスが使える様になります。PythonでこのPVアクセスによるモジュールも同時に開発されており、EPICS 7が中心となった時には、PVアクセスのためのモジュール [PvaPy][pvapy]が用意されています。\n",
    "\n",
    "[pvapy]: https://github.com/epics-base/pvaPy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c3dfeff-9137-4721-8123-ca8351e04cda",
   "metadata": {},
   "source": [
    "## EPICS チャンネルのまとめ\n",
    "PythonでEPICS チャンネルを取り扱うために必要なEPICSチャンネルについての知識をまとめておきます。\n",
    "EPICSについての詳しい解説は、[J-PARC 制御グループWiki のEPICSカテゴリページ][EPICS カテゴリ] およびその中で紹介されている資料をご覧ください。\n",
    "\n",
    "[www-cont]: http://www-cont.j-parc.jp/mediawiki/index.php/EPICS\n",
    "[EPICS カテゴリ]: http://www-cont.j-parc.jp/mediawiki/index.php/%E3%82%AB%E3%83%86%E3%82%B4%E3%83%AA:EPICS\n",
    "\n",
    "\n",
    "### チャンネル\n",
    "\n",
    "* EPICSベースの制御システムにある情報はチャンネル名を通じて読み/書き/監視される。\n",
    "* 全てのチャンネルはそれぞれのチャンネル名で区別される。\n",
    "* チャンネル名の一般形は<レコード名>.<フィールド名>の形式である。\n",
    "\n",
    "  * .<フィールド名>が省略された場合、それは<レコード名>.VALと解釈されます。\n",
    "* 各チャンネルは固有のデータ型を持つ。\n",
    "\n",
    "  * 整数／浮動小数点/列挙型/ストリング/それらのデータの一次元配列\n",
    "\n",
    "### チャンネル オブジェクト\n",
    "\n",
    "* python caモジュールでは、　各チャンネルに対して、channelオブジェクトを生成します。\n",
    "\n",
    "  * python ca モジュールでは、チャンネルオブジェクトの生成時にチャンネルの探索が行われます。\n",
    " \n",
    "    * 必要なチャンネルをどのIOCが持っているかをCAが自動的に探します。\n",
    "\n",
    "    * 探索の範囲はEPICS_CA_ADDR_LISTなどの環境変数で変化します。通常探索には100m秒オーダーの時間がかかります。\n",
    "    \n",
    "    * IOC(EPICS CA サーバー）とネットワークを通して、直接通信できない計算機から、IOCのチャンネルにアクセスするためには、IOCとPCの間にCA  ゲートウェイを設置する必要があります。\n",
    "  \n",
    "\n",
    "* channel オブジェクトには、get, put, monitorの三つの基本メソッドがあります。\n",
    "\n",
    "  * 最新の値を読み出すために、`channel.get()` を使います。\n",
    "  \n",
    "  * チャンネルに値を設定するために、`channel.put(values,..)` を使います。\n",
    "  \n",
    "  * チャンネルの値に変化があった時に、コールバック関数を呼び出すように、`channel.monitor(callback)` を使います。\n",
    "  \n",
    "  * これらのメソッドはいずれも非同期動作をします。複数のチャンネルの操作を効率よく実行するために、`channel.pend_event()`,`.poll()`,`.flush()`や`.pend_io()`などのメソッドを呼び出して初めてIOCに要求が送り出されます。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72e95c43-8a8f-4997-a57c-4856e74c467e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": [
     "chap1"
    ]
   },
   "source": [
    "# Python caによる EPICS チャンネルの操作の実例\n",
    "\n",
    "プログラムからのチャンネル操作は、open/close(connect/disconnet), get(read),put(write), monitor　の各機能を使って行われます。\n",
    "\n",
    "## python caモジュール\n",
    "\n",
    "KEKで開発されたPython ca モジュールでは、このチャンネルを操作するためのchannel クラスが定義されています。ca モジュールではこの他に、\n",
    "Get, Put, Monitorなどのテスト用関数も提供されています。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "536003ed-12f8-4e4b-ad46-725e9706390f",
   "metadata": {},
   "source": [
    "caモジュールをpythonプログラム中で使うために、caモジュールをインポート( `import` )します。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8eacc15c-a13b-4ce6-a28a-0695033c9d0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.23.3.3\n"
     ]
    }
   ],
   "source": [
    "import ca\n",
    "print(ca.release)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c212dce0-6728-4d01-9981-2933116d2481",
   "metadata": {},
   "source": [
    "## JLANネットワーク内から MR CAgateway にアクセスする。\n",
    "EPICS チャンネルアクセスをpythonで実行する一例を示します。\n",
    "このプログラムでは、JLANネットワークから、J-PARC加速器制御システムのランナンバー(Run number: \"MRCO:TMG_CER:VAL:RUNNO\")情報を\n",
    "入手します。\n",
    "\n",
    "JLANネットワークは、加速器制御システム内のEPICSとはファイアーウォールで切り離されているため、制御システムの情報を入手するためには、\n",
    "チャンネルアクセス　ゲートウェイ(CA Gateway)と呼ばれるサーバを経由する必要があります。\n",
    "\n",
    "\n",
    "JLANからJ-PARC MRの制御に使われるチャンネルを読み出すために、\n",
    "MR EPICS CA-gateway(jlandmzcagw01.j-parc.jp)が用意されています。今回もこのサーバー経由で 加速器制御システムの信号をモニタします。\n",
    "\n",
    "このCA Gatewayを利用する際には、\n",
    "EPICS CAライブラリの`import`前に、環境変数`EPICS_CA_ADDR_LIST`にこのEPICS CA Gatewayのアドレス `jlandmzcagw01.j-parc.jp` を追加します。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d99fa8e-9007-44d3-bb2a-b5654a93f289",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 環境変数の設定"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b5dff2ed-921d-420a-b606-971f36e6155f",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jlandmzcagw01.j-parc.jp : 192.153.109.232\n",
      "FQDN: jlandmzcagw01.j-parc.jp\n",
      "addr info: ('jlandmzcagw01.j-parc.jp', ['232.109.153.192.in-addr.arpa'], ['192.153.109.232'])\n",
      "os.environ[\"EPICS_CA_ADDR_LIST\"]='jlandmzcagw01.j-parc.jp 127.0.0.1'\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import socket\n",
    "\n",
    "# 環境変数　\"EPICS_CA_ADDR_LIST\"に MR CA gatewayのアドレスを追加する。\n",
    "MR_CA_GATEWAY = \"jlandmzcagw01.j-parc.jp\"  # MR CA gateway address:jlandmzcagw01.j-parc.jp\n",
    "os.environ[\"EPICS_CA_ADDR_LIST\"] = \" \".join((\n",
    "  MR_CA_GATEWAY,\n",
    "  os.environ.get(\"EPICS_CA_ADDR_LIST\",\"\"),\n",
    "  #\"127.0.0.1\"\n",
    "  ))\n",
    "# 正しいアドレスが設定されているかどうかを確認\n",
    "print(MR_CA_GATEWAY, \":\", socket.gethostbyname(MR_CA_GATEWAY))\n",
    "# ホストアドレスから、ホスト名を確認してみる。\n",
    "print(\"FQDN:\",socket.getfqdn(\"192.153.109.232\"))\n",
    "print(\"addr info:\", socket.gethostbyaddr(\"192.153.109.232\"))\n",
    "#\n",
    "# 環境変数を確認\n",
    "print( f'{os.environ[\"EPICS_CA_ADDR_LIST\"]=}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8a6d548-a480-4cf2-995e-633da9a1d58c",
   "metadata": {},
   "source": [
    "#### 環境変数の設定\n",
    "J-PARC 構内ネットワーク(J-LAN)から加速器制御ネットワークのデータを読み出すために、チャンネルアクセス　ゲートウェイ \"jlandmzcagw01.j-parc.jp\" を\n",
    "環境変数 `EPICS_CA_ADDR_LIST` に設定します。　環境変数`EPICS_CA_ADDR_LIST`はEPICS CAがチャンネル検索のためのブロードキャストメッセージを送るネットワークアドレスのリストを指定します。EPICS CAライブラリはこれらのネットワークアドレスに、チャンネル名の検索パケットをブロードキャストとして送信します。このブロードキャストアドレスを受け取ったIOCは、検索チャンネル名のチャンネルを自身のデータベース中に持っている場合、ブロードキャストアドレスの送信元に、応答のメッセージを送信します。\n",
    "\n",
    "\n",
    "##### `os.environ.get(\"EPICS_CA_ADDR_LIST\",\"\")`:\n",
    "\n",
    "`os.environ`は定義済みの環境変数をキーとする辞書型データです。\n",
    "辞書型データの`.get()`メソッドは文字列として与えられた文字列がキーとして定義済みであれば、その値を返します。\n",
    "第一引数として与えられた文字列のキーが未定義の時は、第2引数がある場合にはそれを値として返し、そうでなければ`None`を返します。\n",
    "\n",
    "つまり、`os.environ.get(key, default)`呼び出しは、次の式と等価です。\n",
    "\n",
    "``` python\n",
    "os.environ[key] if key in os.environ else default\n",
    "#あるいは、\n",
    "default if key not in os.environ else os.environ(key)\n",
    "```\n",
    "\n",
    "これを使って、`MR_CA_GATEWAY`が先頭に入った環境変数`EPICS_CA_ADDR_LIST`を　設定します。\n",
    "\n",
    "``` python\n",
    "  os.environ[\"EPICS_CA_ADDR_LIST\"] = \" \".join( \n",
    "    (MR_CA_GATEWAY, os.environ.get(\"EPICS_CA_ADDR_LIST\",\"\"))\n",
    "  )\n",
    "```\n",
    "\n",
    "#### `socket.gethostbyname(MR_CA_GATEWAY)` など\n",
    "\n",
    "このセクションは正しいアドレスが設定されたかどうかを確認しています。`ca`モジュールの利用には影響しません。\n",
    "\n",
    "`socket.gethostbyname()`関数は引数のホスト名のIPアドレス(\"xxx.yyy.zzz.ttt\"の形式の文字列)を返します。\n",
    "`socket.getfqdn()`関数は逆に、IPアドレスからホスト名(fqdn:Fully Qualified Domain Name)を返します。\n",
    "`socket.gethostbyaddr()`はホスト名あるいはIPアドレスから、(正規化されたホスト名、aliasのリスト、IPアドレスのリスト]を返します。エイリアスリストに現れている, \"ttt.zzz.yyy.xxx.in-addr.arpa\"はIPv4での逆引きアドレスと呼ばれるものです。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bebb5678-a238-48ae-acf5-52b705141dca",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### caのインポートと、チャンネルからのデータの読み込み"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "36348f98-004d-4389-be83-3ed83f60c90f",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "default(native): 89.0\n",
      "float: 89.0\n",
      "string: 89.0000\n",
      "integer: 89\n"
     ]
    }
   ],
   "source": [
    "import ca\n",
    "# ca moduleのGet 関数を使って、RUN ナンバーを(色々なデータ型で）読み出す。\n",
    "RUNNO_CHN=\"MRCO:TMG_CER:VAL:RUNNO\"\n",
    "print( \"default(native):\", ca.Get(RUNNO_CHN))\n",
    "for key,t in { \n",
    "  \"float\":ca.DBF_FLOAT,\n",
    "  \"string\":ca.DBF_STRING,   \n",
    "  \"integer\":ca.DBF_INT}.items():\n",
    "   print( f\"{key}: {ca.Get(RUNNO_CHN, Type=t)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd2dd2a8-9e4c-48cd-8c23-1fbc0f2a8f90",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### caのインポートと、チャンネルからのデータの読み込み\n",
    "環境変数 `EPICS_CA_ADDR_LIST`を設定した後、`ca`モジュールをインポートします。\n",
    "\n",
    "```python\n",
    "import ca\n",
    "```\n",
    "\n",
    "ca モジュールはインポートされた時点での環境変数を使います。ここでは、pythonの中で、環境変数を設定していますが、\n",
    "pythonを起動する前に環境変数が設定されていれば, python の中で設定しないという選択もあります。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1becf5ec-b8d9-4a78-b36a-2b792013146e",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### チャンネルの値の読み出し\n",
    "\n",
    "次に`.Get()`関数を使って、チャンネルの値を確認します。\n",
    "\n",
    "``` python\n",
    "RUNNO_CHN=\"MRCO:TMG_CER:VAL:RUNNO\"\n",
    "print( \"default(native):\", ca.Get(RUNNO_CHN))\n",
    "```\n",
    "\n",
    "`ca.Get()`は引数に与えられた名前のチャンネルの値を返します。`Type`引数を使うことで、返される値のデータ型を指定できます(`type`はpythonの予約語ですので、引数の名前として使うことができません）。\n",
    "\n",
    "``` python\n",
    "for key,t in { \n",
    "  \"float\":ca.DBF_FLOAT,\n",
    "  \"string\":ca.DBF_STRING,   \n",
    "  \"integer\":ca.DBF_INT}.items():\n",
    "   print( f\"{key}: {ca.Get(RUNNO_CHN, Type=t)}\")\n",
    "```\n",
    "`ca.Get()`は`ca`モジュールの中で、簡便に チャンネルを***テスト***するために用意されています。`ca.Put`, `ca.Monitor`も同様です。\n",
    "これらの関数の利用は、**テスト目的**だけに利用し、実際のpythonプログラムでは、後述の`channel`オブジェクトとそのメソッドを使うことを\n",
    "お勧めします。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c70a3ba3-7a9d-4060-a9e0-d3526669a242",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# チャンネル　オブジェクト\n",
    "pythonの`ca`モジュールは、基になっているEPICS CAライブラリの`channel`構造体を`channel`クラスとして実装しています。`ca`モジュールの基本はこのチャンネルオブジェクトを使いこなすことです。\n",
    "\n",
    "チャンネルオブジェクトについての基本的な操作は、\n",
    "\n",
    " 1. チャンネルオブジェクトを生成する( `ca.channel()`)\n",
    " 1. チャンネルの現在値を読み出す(`.get()`)\n",
    " 1. チャンネルに新しい値を設定する(`.put()`)\n",
    " 1. チャンネルの値の変化を監視する( `.monitor()`)\n",
    " \n",
    "です。以下のセクションでこれらの基本的な関数の使用法を説明します。\n",
    "このほかにも、補助的な関数がありますが、以下の説明の中でご紹介していきます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5c03ab18-0911-4e49-815d-d4da6150d1fd",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before wait_conn ch.isConnected()=False 2022-09-13 11:55:18.983099\n",
      "after wait_conn ch.isConnected()=True 2022-09-13 11:55:19.038432\n",
      "ch.val=None 2022-09-13 11:55:19.038613\n",
      ". 2022-09-13 11:55:19.051279\n",
      ". 2022-09-13 11:55:19.063932\n",
      ". 2022-09-13 11:55:19.075809\n",
      "ch.val='22/09/13 11:55:18' 2022-09-13 11:55:19.076005\n"
     ]
    }
   ],
   "source": [
    "import ca,datetime\n",
    "ch=ca.channel(\"MRCO:TIOC_CONT_CER01:VAL:TM\")\n",
    "print(f\"before wait_conn {ch.isConnected()=}\", datetime.datetime.now())\n",
    "ch.wait_conn()\n",
    "print(f\"after wait_conn {ch.isConnected()=}\", datetime.datetime.now())\n",
    "ch.get()\n",
    "print(f\"{ch.val=}\",datetime.datetime.now())\n",
    "ca.flush()\n",
    "while (r:=ch.val) == None:\n",
    "  ca.pend_event(0.01)\n",
    "  print(\".\", datetime.datetime.now(),  end=None)\n",
    "print(f\"{ch.val=}\",datetime.datetime.now())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "445f0643-d523-4aa5-bc73-cc2a74060cc0",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## チャンネルの生成\n",
    "``` python\n",
    "ch=ca.channel(\"MRCO:TIOC_CONT_CER01:VAL:TM\")\n",
    "print(f\"before wait_conn {ch.isConnected()=}\", datetime.datetime.now())\n",
    "ch.wait_conn()\n",
    "print(f\"after wait_conn {ch.isConnected()=}\", datetime.datetime.now())\n",
    "```\n",
    "`ca`モジュールの`channel`クラスを利用するために、各チャンネル毎に`ca.channel`クラスのオブジェクト(あるいはインスタンス）を作成します。pythonでのインスタンスは、クラス名に作成するチャンネルのチャンネル名を引数として与えて呼び出すことで、作成されます。チャンネルインスタンスの作成には、チャンネルの探索、 IOCからの応答待ち、IOCとのネットワークコネクションの確立といった手続きが含まれています。ネットワークの性能と状況にも依存しますが、これには100m秒オーダーの時間がかかることもあります。このため、`ca`モジュールでは、利用可能なチャンネル作成の完了を待つための関数、`channel.wait_conn()`メソッドを用意しています。\n",
    "\n",
    "存在しないチャンネル名を引数として与えた場合には、この`channel.wait_conn()`呼び出しは例外`ca.ECA_BADCHID` を発生します。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4468d1d-6e7a-4511-a477-71a34a3d8011",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## `.get()`呼び出しによる値の読み出し\n",
    "\n",
    "``` python\n",
    "ch.get()\n",
    "print(f\"{ch.val=}\",datetime.datetime.now())\n",
    "ca.flush()\n",
    "while (r:=ch.val) == None:\n",
    "  ca.pend_event(0.01)\n",
    "  print(\".\", datetime.datetime.now(),  end=None)\n",
    "print(f\"{ch.val=}\",datetime.datetime.now())\n",
    "```\n",
    "* `.get()`を呼び出して、IOC-DBにチャンネルの値を要求します。\n",
    "* EPICS CAライブラリでは、`.get()`呼び出しは、この要求をチャンネルライブラリのキューに入れるだけです。\n",
    "* `.flush()`などを呼び出して初めて、ネットワーク経由でリクエストが送信されます。\n",
    "* 10m秒毎に値の更新をチェックしながら、待ちます。この例では40m秒程度待ってから初めて値の更新の応答が届いたことがわかります。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "815a4127-de13-4671-8a64-ba59349ea195",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ch.val='22/09/13 11:55:18' 2022-09-13 11:55:19.084677\n",
      "ch.val='22/09/13 11:55:18' 2022-09-13 11:55:19.084846\n"
     ]
    }
   ],
   "source": [
    "ch.get()\n",
    "print(f\"{ch.val=}\",datetime.datetime.now())\n",
    "ca.flush()\n",
    "while (r:=ch.val) == None:\n",
    "  ca.pend_event(0.01)\n",
    "  print(\".\", datetime.datetime.now(),  end=None)\n",
    "print(f\"{ch.val=}\",datetime.datetime.now())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bc74e89-1113-4276-be19-0651084cabbf",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## EPICSの`.monitor()` 機能\n",
    "\n",
    "EPICSのチャンネルアクセス(CA)は通常のファイル操作と似たところがあります。\n",
    "File操作においては `open/read/write` が基本操作ですが、これらは、CAにおける`channel/get/put` とほぼ対応しています。\n",
    "EPICSのチャンネルアクセス(CA)にはさらに`monitor()`という機能が追加されているのはファイル操作と大きく異なっているところです。別の見方をすると、EPICS CAの利用では、`monitor()`を使いこなすことが重要だということになります。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f27230b8-f694-4ca1-b7d3-04f9c960e688",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `.monitor`機能とは\n",
    "\n",
    "機器制御では、制御対象の状態がある状態が変化した場合(例えば温度が制限値を超えた）時、適切な制御操作を行う(例えば、ファンの回転数を上げる）必要があります。　素早い応答のためには、現在値を頻繁に読み出すことが必要となります(このような方法を`poll`と呼びます）。一方で、こうした頻繁なデータ読み出しは、ネットワークの負荷を不必要に増やすことになります。\n",
    "\n",
    "このような場合に、EPICS CAの`.monitor()`機能は有効です。\n",
    "`.monitor()`機能では、CAクライアントは監視対象のチャンネルに対して、`.monitor`開始のリクエストを送ります。この際、コールバック関数も同時に指定しておくと、制御対象のチャンネルの値が、事前に設定されている条件を超えて変化した場合にのみ、IOC(EPICS DB)からCAクライアントへ新しい値が送信されます（monitor エベント)。CA クライアントでは、このエベントを受信すると、指定したコールバック関数が実行されます。 `.monitor()`機能を使うことで、応答性を犠牲にすることなく、ネットワーク上の不必要な負荷を削減することができるという訳です。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88a1985a-155e-493b-9d61-891203b418b5",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `.monitor`とコールバック関数\n",
    "\n",
    "GUIシステムでは、キーボード入力などのエベントとそれに対応するコールバックの仕組みが一般的に使われています。EPICS CAの　`.monitor`とコールバックの関係もそれらの仕組みと同じように使われます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8ebb8f44-cbb6-432d-b347-14671e6342ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start monitor None\n",
      "{'.val': None, 'cb val': '22/09/13 11:55:18'}\n",
      "{'.val': None, 'cb val': '22/09/13 11:55:19'}\n",
      "{'.val': None, 'cb val': '22/09/13 11:55:20'}\n",
      "{'.val': None, 'cb val': '22/09/13 11:55:21'}\n",
      "{'.val': None, 'cb val': '22/09/13 11:55:22'}\n",
      "{'.val': None, 'cb val': '22/09/13 11:55:23'}\n",
      "end None\n"
     ]
    }
   ],
   "source": [
    "ch=ca.channel(\"MRCO:TIOC_CONT_CER01:VAL:TM\")\n",
    "ch.wait_conn()\n",
    "\n",
    "def cb(vals,ch=ch):\n",
    "    #ch.update_val(vals)\n",
    "    print({\".val\":ch.val,\"cb val\":vals[0]})\n",
    "\n",
    "ch.monitor(callback=cb) #このチャンネルのモニタを設定する。\n",
    "\n",
    "print('start monitor', ch.val) \n",
    "ca.flush() # ここで初めて、モニタ要求がIOC/EPICS DBに送られる。\n",
    "ca.pend_event(5) #5秒間　モニタエベントを待つ。\n",
    "ch.clear_monitor() #モニタを取り消す。\n",
    "print(\"end\", ch.val)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e76dbada-6e40-4b64-b122-c4cf62aac1be",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### vals\n",
    "\n",
    "コールバック関数は一つの引数`vals`を持ちます。valsの中身は、`monitor`関数を\n",
    "呼び出す際の設定によって変化しますが、`(value, status, callback state[, time stamp [, control value])`となっています。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a204a590-b61e-412f-a06e-42ecea188c29",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cb vals ('22/09/13 11:55:23', 0, 0, 1031885723.524399) Tue Sep 13 11:55:23.524 2022\n",
      "cb vals ('22/09/13 11:55:24', 0, 0, 1031885724.524871) Tue Sep 13 11:55:24.524 2022\n",
      "cb vals ('22/09/13 11:55:25', 0, 0, 1031885725.525802) Tue Sep 13 11:55:25.525 2022\n",
      "cb vals ('22/09/13 11:55:26', 0, 0, 1031885726.52673) Tue Sep 13 11:55:26.526 2022\n",
      "cb vals ('22/09/13 11:55:27', 0, 0, 1031885727.527649) Tue Sep 13 11:55:27.527 2022\n",
      "cb vals ('22/09/13 11:55:28', 0, 0, 1031885728.529073) Tue Sep 13 11:55:28.529 2022\n"
     ]
    }
   ],
   "source": [
    "ch=ca.channel(\"MRCO:TIOC_CONT_CER01:VAL:TM\")\n",
    "ch.wait_conn()\n",
    "\n",
    "def cb(vals):\n",
    "  # コールバック関数へ渡される値 vals を印刷する\n",
    "  print(\"cb vals\", vals, ca.TS2Ascii(vals[3]))\n",
    "\n",
    "ch.monitor(callback=cb) #このチャンネルのモニタを設定する。\n",
    "\n",
    "ca.flush() # ここで初めて、モニタ要求がIOC/EPICS DBに送られる。\n",
    "ca.pend_event(5) #5秒間　モニタエベントを待つ。\n",
    "ch.clear_monitor() #モニタを取り消す。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57caf92f-d8ba-43f9-8ab3-0b6a43e44866",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `.update_val()`の利用\n",
    "\n",
    "上記の例では、monitorエベント毎に表示されている `vals`の値はエベント毎に異なって\n",
    "いますが、チャンネルオブジェクトの値`.val`自体は更新されていません。\n",
    "\n",
    "`.val`をmonitorエベント毎に更新させるためには、コールバック関数の中で、`.update_val(vals)`を呼び出す必要があります。これは、一つのチャンネルオブジェクトに対して、複数のモニタコールバックを設定することが可能であることから、複数のコールバックで`.val`フィールドがそれぞれ更新されてしまうことを避けるためです。\n",
    "\n",
    "コールバック関数の中で、`.update_vall()`関数を呼び出した例を次に示します。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4c232128-f54d-4a79-aa5a-203564d32b67",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start monitor None\n",
      "{'.val': '22/09/13 11:55:28', 'cb val': '22/09/13 11:55:28'}\n",
      "{'.val': '22/09/13 11:55:29', 'cb val': '22/09/13 11:55:29'}\n",
      "{'.val': '22/09/13 11:55:30', 'cb val': '22/09/13 11:55:30'}\n",
      "{'.val': '22/09/13 11:55:31', 'cb val': '22/09/13 11:55:31'}\n",
      "{'.val': '22/09/13 11:55:32', 'cb val': '22/09/13 11:55:32'}\n",
      "{'.val': '22/09/13 11:55:33', 'cb val': '22/09/13 11:55:33'}\n",
      "end 22/09/13 11:55:33\n"
     ]
    }
   ],
   "source": [
    "ch=ca.channel(\"MRCO:TIOC_CONT_CER01:VAL:TM\")\n",
    "ch.wait_conn()\n",
    "\n",
    "def cb(vals,ch=ch):\n",
    "    ch.update_val(vals) \n",
    "    print({\".val\":ch.val,\"cb val\":vals[0]})\n",
    "\n",
    "ch.monitor(callback=cb)\n",
    "\n",
    "print('start monitor', ch.val)\n",
    "ca.flush()\n",
    "ca.pend_event(5)\n",
    "ch.clear_monitor()\n",
    "print(\"end\", ch.val)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcc5851b-8dae-407e-8977-108b6c45f89d",
   "metadata": {},
   "source": [
    "このように、`.update_val()`をコールバック関数の中で呼び出すことで、\n",
    "`.val`フィールドも更新されて行きます。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f684fd4-d7ff-4cea-80a4-5fd637fdf734",
   "metadata": {
    "tags": []
   },
   "source": [
    "## チャンネルオブジェクトの`.autoUpdate()`メソッドを使う。\n",
    "\n",
    "チャンネルの`.val`フィールドがモニタエベント毎に更新させるようにするには、`.update_val()`を呼び出すコールバックを設定してやれば良いだけです。\n",
    "これを簡単に行うために、チャンネルオブジェクトには`.autoUpdate()`関数が定義されています。\n",
    "\n",
    "チャンネルオブジェクトの`.autoUpdate()`を使うと、適宜`ca.pend_event()`を呼ぶだけで、最新の値をチャンネルの`.val`プロパティから取得できます。\n",
    "\n",
    "`.autoupdate()`呼び出しは、概ね、\n",
    "\n",
    "``` python\n",
    "ch.monitor(lambda valstat,ch=ch: ch.update_val(valstat))\n",
    "```\n",
    "\n",
    "と等価です。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "57f8a9cb-6f11-4021-9336-aa92532857f0",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 before pend None\t after  pend 22/09/13 11:55:34\n",
      "1 before pend 22/09/13 11:55:34\t after  pend 22/09/13 11:55:35\n",
      "2 before pend 22/09/13 11:55:35\t after  pend 22/09/13 11:55:36\n",
      "3 before pend 22/09/13 11:55:36\t after  pend 22/09/13 11:55:37\n",
      "4 before pend 22/09/13 11:55:37\t after  pend 22/09/13 11:55:38\n"
     ]
    }
   ],
   "source": [
    "# auotoupdate\n",
    "ch=ca.channel(\"MRCO:TIOC_CONT_CER01:VAL:TM\")\n",
    "ch.wait_conn()\n",
    "ch.autoUpdate()\n",
    "#ca.pend_event(0.1)\n",
    "ch.flush()\n",
    "\n",
    "for i in range(5):\n",
    "  print(i,\"before pend\", ch.val, end=\"\")\n",
    "  ca.pend_event(1)\n",
    "  print(\"\\t after  pend\", ch.val)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "bce3505a-3794-4527-969f-c1adbb1941ad",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start monitor None\n",
      "{'.val': '22/09/13 11:55:38', 'cb val': '22/09/13 11:55:38', 'TS': 'Tue Sep 13 11:55:38.539 2022', 'now': '2022-09-13 11:55:39.469646'}\n",
      "{'.val': '22/09/13 11:55:39', 'cb val': '22/09/13 11:55:39', 'TS': 'Tue Sep 13 11:55:39.539 2022', 'now': '2022-09-13 11:55:39.585219'}\n",
      "{'.val': '22/09/13 11:55:40', 'cb val': '22/09/13 11:55:40', 'TS': 'Tue Sep 13 11:55:40.540 2022', 'now': '2022-09-13 11:55:40.643592'}\n",
      "{'.val': '22/09/13 11:55:41', 'cb val': '22/09/13 11:55:41', 'TS': 'Tue Sep 13 11:55:41.541 2022', 'now': '2022-09-13 11:55:41.676078'}\n",
      "{'.val': '22/09/13 11:55:42', 'cb val': '22/09/13 11:55:42', 'TS': 'Tue Sep 13 11:55:42.542 2022', 'now': '2022-09-13 11:55:42.601956'}\n",
      "{'.val': '22/09/13 11:55:43', 'cb val': '22/09/13 11:55:43', 'TS': 'Tue Sep 13 11:55:43.544 2022', 'now': '2022-09-13 11:55:43.634793'}\n",
      "end 22/09/13 11:55:43 2022-09-13 11:55:44.457316\n"
     ]
    }
   ],
   "source": [
    "ch=ca.channel(\"MRCO:TIOC_CONT_CER01:VAL:TM\")\n",
    "ch.wait_conn()\n",
    "ch.autoUpdate(); \n",
    "\n",
    "def cb(vals,ch=ch):\n",
    "    TS=ca.TS2Ascii(ch.ts)\n",
    "    now=str(datetime.datetime.now())\n",
    "    print({\".val\":ch.val, \"cb val\":vals[0],\n",
    "           \"TS\":TS,\n",
    "          \"now\":now})\n",
    "ch.monitor(callback=cb)\n",
    "\n",
    "print('start monitor',ch.val)\n",
    "ca.flush()\n",
    "ca.pend_event(5)\n",
    "ch.clear_monitor()\n",
    "print(\"end\", ch.val, str(datetime.datetime.now()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd73230d-ff27-46a3-a1ff-d5cd8dbe2e34",
   "metadata": {},
   "source": [
    "## チャンネルに値を設定する(`.put()`)\n",
    "CAでは、EPICS レコードの `.val`フィールド以外のフィールドもチャンネルとして、読み書きします。ここでは、レコードの `.SCAN` フィールドを　`.put()` メソッドを使って書き換えてみます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b9589368-a8b8-4ce4-aaed-79b4ebd7e1eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "('fred', ':', 0.08651865415426871, 2, 5, 'Tue Sep 13 11:55:42.990 2022')\n",
      "('fred', ':', 0.4712291142137789, 0, 0, 'Tue Sep 13 11:55:44.994 2022')\n",
      "('fred', ':', 0.47269398031586174, 0, 0, 'Tue Sep 13 11:55:46.994 2022')\n",
      "6 1 second\n",
      "('fred', ':', 0.1927824826428626, 2, 5, 'Tue Sep 13 11:55:47.991 2022')\n",
      "('fred', ':', 0.9475394827191577, 2, 3, 'Tue Sep 13 11:55:48.994 2022')\n",
      "('fred', ':', 0.9090867475394827, 2, 3, 'Tue Sep 13 11:55:49.994 2022')\n",
      "5 2 second\n"
     ]
    }
   ],
   "source": [
    "fred=ca.channel('fred.SCAN')\n",
    "fred.wait_conn()\n",
    "fred.autoUpdate()\n",
    "fred.pend_event(0.01)\n",
    "print(fred.val)\n",
    "ca.Monitor('fred')\n",
    "ca.pend_event(3)\n",
    "fred.put(6);fred.pend_event(0.01)\n",
    "print(fred.val, ca.Get(\"fred.SCAN\", Type=ca.DBF_STRING))\n",
    "ca.pend_event(3)\n",
    "fred.put(5);fred.pend_event(0.01)\n",
    "print(fred.val, ca.Get(\"fred.SCAN\", Type=ca.DBF_STRING))\n",
    "ca.ClearAll()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da0b8f7d-b9b8-467a-a2c0-263266895f1a",
   "metadata": {},
   "source": [
    "### waveformレコードなどにアレイデータをチャンネル経由で書き込む。\n",
    "weveformレコードの`.val`フィールドの様に、一次元の配列を値として持つチャンネルに値を書き込むことも（もちろん）できます。python CA中では、\n",
    "``` python\n",
    "adata=[1,2,3,4,5,6,7,8,9,10]\n",
    "wvch.put(*adata)\n",
    "```\n",
    "と書くことになります。Pythonの構文ルールでは、上記のプログラムは、\n",
    "\n",
    "``` python\n",
    "wvch.put(1,2,3,4,5,6,7,8,9,10)\n",
    "```\n",
    "と書くのと等価です。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de244962-a3bd-4a69-ba49-2f0a1a2967b8",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# Jupyterlab/ipywidgetを使ったGUI\n",
    "Jupyterlabをアップデートしたら、ipywidgetが動かなくなりました。とりあえず、この件については、\n",
    "配布元で修正が行われるの待つことにして、このノートではスキップします。\n",
    "(2022/07/19)\n",
    "Jupyterlab Desktopにしたら復活しました。(2022/08/02)\n",
    "しかしJupyterlab Desktophaは x86_64でしか動作しません。（2022／09／05）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "cce8ee98-2aff-49f3-8e48-a6453f21af7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import ipywidgets as widgets\n",
    "from IPython.display import display"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6359b0a3-2e33-4a45-895f-23715ade74bf",
   "metadata": {},
   "source": [
    "`Text` ウィジェットを作成し、チャンネルのmonitorに登録したコールバック関数で、\n",
    "ウィジェットの値を更新します。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "52f147ad-f682-43b3-8cf1-f6944cb84fa0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a339c720e74341a391d0e6db81c6cf24",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Text(value='Hello World', description='String:', placeholder='Type something')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "t=widgets.Text(\n",
    "    value='Hello World',\n",
    "    placeholder='Type something',\n",
    "    description='String:',\n",
    "    disabled=False\n",
    ")\n",
    "ch=ca.channel(\"MRCO:TIOC_CONT_CER01:VAL:TM\")\n",
    "ch.wait_conn()\n",
    "def cb(vals,t=t):\n",
    "    t.value=vals[0]\n",
    "ch.monitor(callback=cb)\n",
    "ca.flush()\n",
    "display(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1918238d-8339-422a-94fb-04c5d7469cf5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "db13584f3a574db99c06752eae328d12",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Text(value='Hello World', description='String:', placeholder='Type something')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "t=widgets.Text(\n",
    "    value='Hello World',\n",
    "    placeholder='Type something',\n",
    "    description='String:',\n",
    "    disabled=False\n",
    ")\n",
    "ch=ca.channel(\"MRCO:TIOC_CONT_CER01:VAL:TM\")\n",
    "ch.wait_conn()\n",
    "ch.autoUpdate()\n",
    "def cb(vals,t=t):\n",
    "    t.value=ch.val\n",
    "ch.monitor(callback=cb)\n",
    "ca.flush()\n",
    "display(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "928f7964-4245-47d0-a4ea-f1713c3c06cf",
   "metadata": {},
   "source": [
    "# waveform データのグラフを作成する。\n",
    "ここでは、`python`のグラフ作成ライブラリの一つである`matplotlib`を使って、EPICS CAで波型データを読み出して、\n",
    "グラフ化してみます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f654d294-aab7-4217-b8ae-b528f2d18847",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'waveform'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ca.Get(\"350BTMON:BLM_P_ALL:COR:K2.RTYP\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "58368cc2-afd0-42bb-8df6-c9a70d4f3477",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ca.Get(\"350BTMON:BLM_P_ALL:COR:K3.SCAN\",Type=ca.DBR_NATIVE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "472d2a50-df23-4b59-887b-130eb9b75b68",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib, matplotlib.pyplot as pyplot\n",
    "import ca\n",
    "ch_names=(\n",
    "  \"350BTMON:BLM_P_ALL:COR:K1\", \n",
    "  \"350BTMON:BLM_P_ALL:COR:K2\",\n",
    "  \"350BTMON:BLM_P_ALL:COR:K3\",\n",
    "  \"alan\", #softExcas\n",
    "  \"alan2\",  #softExcas\n",
    ")\n",
    "channels=[ ca.channel(ch) for ch in ch_names]\n",
    "channels[-1].wait_conn() # wait_for\n",
    "for ch in channels: ch.autoUpdate()\n",
    "ca.pend_event(0.1) # 最後のchannelが繋がれば、ほとんどの場合、それまでに作成されたチャンネルは接続ずみ\n",
    "lines=[pyplot.plot(ch.val, label=ch.name)[0] for ch in channels]\n",
    "#pyplot.ion()\n",
    "pyplot.legend()\n",
    "pyplot.draw()\n",
    "pyplot.pause(0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c9105ce-3f06-48a0-a396-c0d5f6be5df2",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9",
   "language": "python3",
   "name": "python3.9"
  },
  "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.13"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}