diff --git a/doc/Makefile b/doc/Makefile index de0c902961f918a8d10a70d8b329700dd7c5c414..8f3ff303ca77b1927d6b49d30a9abdbd263d7886 100644 --- a/doc/Makefile +++ b/doc/Makefile @@ -58,7 +58,7 @@ $(AUTODOCDIR): $(MODULEDIR) # $(AUTODOCBUILD) -f -o $@ $^ doc-requirements: $(AUTODOCDIR) - jupyter nbconvert documentation.ipynb --to rst + @cd jupyter; sh jupyter2markdown.sh; cd .. html: doc-requirements diff --git a/doc/documentation.ipynb b/doc/jupyter/documentation.ipynb similarity index 100% rename from doc/documentation.ipynb rename to doc/jupyter/documentation.ipynb diff --git a/doc/documentation_data/SCRN0005.TXT b/doc/jupyter/documentation_data/SCRN0005.TXT similarity index 100% rename from doc/documentation_data/SCRN0005.TXT rename to doc/jupyter/documentation_data/SCRN0005.TXT diff --git a/doc/documentation_data/SCRN0006.TXT b/doc/jupyter/documentation_data/SCRN0006.TXT similarity index 100% rename from doc/documentation_data/SCRN0006.TXT rename to doc/jupyter/documentation_data/SCRN0006.TXT diff --git a/doc/documentation_data/SCRN0007.TXT b/doc/jupyter/documentation_data/SCRN0007.TXT similarity index 100% rename from doc/documentation_data/SCRN0007.TXT rename to doc/jupyter/documentation_data/SCRN0007.TXT diff --git a/doc/documentation_data/SCRN0008.TXT b/doc/jupyter/documentation_data/SCRN0008.TXT similarity index 100% rename from doc/documentation_data/SCRN0008.TXT rename to doc/jupyter/documentation_data/SCRN0008.TXT diff --git a/doc/documentation_data/SCRN0009.TXT b/doc/jupyter/documentation_data/SCRN0009.TXT similarity index 100% rename from doc/documentation_data/SCRN0009.TXT rename to doc/jupyter/documentation_data/SCRN0009.TXT diff --git a/doc/documentation_data/SCRN0010.TXT b/doc/jupyter/documentation_data/SCRN0010.TXT similarity index 100% rename from doc/documentation_data/SCRN0010.TXT rename to doc/jupyter/documentation_data/SCRN0010.TXT diff --git a/doc/documentation_data/SCRN0011.TXT b/doc/jupyter/documentation_data/SCRN0011.TXT similarity index 100% rename from doc/documentation_data/SCRN0011.TXT rename to doc/jupyter/documentation_data/SCRN0011.TXT diff --git a/doc/documentation_data/SCRN0012.TXT b/doc/jupyter/documentation_data/SCRN0012.TXT similarity index 100% rename from doc/documentation_data/SCRN0012.TXT rename to doc/jupyter/documentation_data/SCRN0012.TXT diff --git a/doc/documentation_data/SCRN0013.TXT b/doc/jupyter/documentation_data/SCRN0013.TXT similarity index 100% rename from doc/documentation_data/SCRN0013.TXT rename to doc/jupyter/documentation_data/SCRN0013.TXT diff --git a/doc/documentation_data/SCRN0014.TXT b/doc/jupyter/documentation_data/SCRN0014.TXT similarity index 100% rename from doc/documentation_data/SCRN0014.TXT rename to doc/jupyter/documentation_data/SCRN0014.TXT diff --git a/doc/documentation_data/SCRN0015.TXT b/doc/jupyter/documentation_data/SCRN0015.TXT similarity index 100% rename from doc/documentation_data/SCRN0015.TXT rename to doc/jupyter/documentation_data/SCRN0015.TXT diff --git a/doc/documentation_data/SCRN0016.TXT b/doc/jupyter/documentation_data/SCRN0016.TXT similarity index 100% rename from doc/documentation_data/SCRN0016.TXT rename to doc/jupyter/documentation_data/SCRN0016.TXT diff --git a/doc/jupyter/jupyter2markdown.sh b/doc/jupyter/jupyter2markdown.sh new file mode 100755 index 0000000000000000000000000000000000000000..cd6264553a788ae9ca2a979bad50a1d8143e61bf --- /dev/null +++ b/doc/jupyter/jupyter2markdown.sh @@ -0,0 +1,2 @@ +#!/usr/bin/env bash +jupyter nbconvert *.ipynb --to rst --output-dir=.. diff --git a/doc/jupyter/usage.ipynb b/doc/jupyter/usage.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..e5b3dc55c124eb91fa4e694b1ecb8acaa0887503 --- /dev/null +++ b/doc/jupyter/usage.ipynb @@ -0,0 +1,272 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Basic Usage\n", + "\n", + "This page assumes a successful [installation](install.html) of NQontrol and all dependencies.\n", + "\n", + "## Hello Servo Example\n", + "\n", + "Here is a minimalistic, `hello world`-like example to show, how to control a servo using the python terminal or a little script." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:Running with mock device!\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Uptime 0s\n" + ] + } + ], + "source": [ + "# Importing a ServoDevice is enough\n", + "from nqontrol import ServoDevice\n", + "\n", + "# Create a new servo device object, connecting to adwin with the device number 1.\n", + "sd = ServoDevice(0)\n", + "\n", + "# Print the timestamp\n", + "print('Uptime {}s'.format(sd.timestamp))\n", + "\n", + "# Get a servo object to control it.\n", + "s = sd.servo(1)\n", + "\n", + "# enable in and output\n", + "s.inputSw = True\n", + "s.outputSw = True" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using a signal generator for the input you will now get the same signal on the output.\n", + "(That is true for signals below about 15 kHz.)\n", + "\n", + "## Apply a ServoDesign\n", + "\n", + "To use a servo for a real control loop we want to have some filters.\n", + "The full documentation is in the [OpenQlab docs](https://las-nq-serv.physnet.uni-hamburg.de/python/openqlab/servodesign.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 576x576 with 2 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Add an integrator and a lowpass\n", + "s.servoDesign.integrator(1e2)\n", + "s.servoDesign.lowpass(5e3)\n", + "\n", + "# Plot how it looks analytically\n", + "import matplotlib.pyplot as plt\n", + "design.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[1.0015692243574656, -0.9999968584122811, 0.0, -0.9968633318334381, 0.0],\n", + " [0.005519854739225482, -1.7786050226116845, 0.8007755579457131, 2.0, 1.0],\n", + " [1.0, 0, 0, 0, 0],\n", + " [1.0, 0, 0, 0, 0],\n", + " [1.0, 0, 0, 0, 0]]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Apply it to our servo\n", + "s.applyServoDesign()\n", + "\n", + "# Control, what happens with the servo\n", + "s.filters" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[True, True, False, False, False]\n", + "1.0\n" + ] + } + ], + "source": [ + "print(s.filterStates)\n", + "print(s.gain)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Control Filters" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Disable all filters\n", + "s.filterStates = [False] * 5\n", + "\n", + "# Enable the second (index = 1) filter\n", + "s.filterState(1, True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Enable a Ramp" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# Choose a slow ramp with a frequency of 1 Hz.\n", + "# Amplitude = 4\n", + "s.enableRamp(20, 4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Start Realtime Plotting" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Start plotting in a background process\n", + "s.realtimePlot(multiprocessing=True)\n", + "\n", + "# disable plotting the output\n", + "s.realtime['ydata'] = ['input', 'aux']\n", + "\n", + "# set constant y limit from -3 to 5 \n", + "s.realtime['ylim'] = (-3, 5)\n", + "\n", + "# stop realtime plotting\n", + "s.stopRealtimePlot()" + ] + } + ], + "metadata": { + "hide_input": false, + "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.7.2" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc/usage.md b/doc/usage.md deleted file mode 100644 index b4421d23d2ee08dabf13ad1e638510520565357f..0000000000000000000000000000000000000000 --- a/doc/usage.md +++ /dev/null @@ -1,113 +0,0 @@ -# Basic Usage - -This page assumes a successful [installation](install.html) of NQontrol and all dependencies. - -## Hello Servo Example - -Here is a minimalistic, `hello world`-like example to show, how to control a servo using the python terminal or a little script. - -```python -# Importing a ServoDevice is enough -from nqontrol import ServoDevice - -# Create a new servo device object, connecting to adwin with the device number 1. -sd = ServoDevice(1) - -# Print the timestamp -print(sd.timeStamp) - -# Create the first servo on channel 1 from 8. -sd.addServo(1) - -# Get the new servo object to control it. -s = sd.servo(1) - -# enable in and output -s.inputSw = True -s.outputSw = True -``` - -Using a signal generator for the input you will now get the same signal on the output. -(That is true for signals below about 15 kHz.) - -## Apply a ServoDesign - -To use a servo for a real control loop we want to have some filters. -The full documentation is in the [OpenQlab docs](https://las-nq-serv.physnet.uni-hamburg.de/python/openqlab/servodesign.html). - -Input: -```python -from OpenQlab.analysis import ServoDesign - -# Create a ServoDesign object -design = ServoDesign() - -# Add an integrator and a lowpass -design.integrator(1e2) -design.lowpass(5e3) - -# Plot how it looks analytically -import matplotlib.pyplot as plt -design.plot() -plt.show() -``` -Output: - - -Input: -```python -# Apply it to our servo -s.applyServoDesign(design) - -# Control, what happens with the servo -print(s.filters) -``` -Output: -```bash -[[1.00313, -0.999993, 0.0, -0.99373, 0.0], - [0.01975, -1.56097, 0.64130, 2.0, 1.0], - [1.0, 0, 0, 0, 0], - [1.0, 0, 0, 0, 0], - [1.0, 0, 0, 0, 0]] -``` -Input: -```python -print(s.filterStates) -print(s.gain) -``` -Output: -```bash -[True, True, False, False, False] -1.0 -``` - -## Control Filters -```python -# Disable all filters -s.filterStates = [False] * 5 - -# Enable the second (index = 1) filter -s.filterState(1, True) -``` - -## Enable a Ramp -```python -# Choose a slow ramp with a frequency of 1 Hz. -# Amplitude = 4 -s.setRamp(1, 4) -``` - -## Start Realtime Plotting -```python -# Start plotting in a background process -s.realtimePlot() - -# disable plotting the output -s.realtime['ydata'] = ['input', 'aux'] - -# set constant y limit from -3 to 5 -s.realtime['ylim'] = (-3, 5) - -# stop realtime plotting -s.stopRealtimePlot() -```