Docs tweaks

Author: coretl

docs/explanations/why-use-pythonIoc.rst

@@ -38,6 +38,7 @@ allows you to write this as:
     # Leave the IOC running with an interactive shell.
     softioc.interactive_ioc(globals())
 
+
 Dynamically created PVs
 -----------------------
 
@@ -76,13 +77,10 @@ this as:
     # Leave the IOC running with an interactive shell.
     softioc.interactive_ioc(globals())
 
-ADD THE PANDA USE CASE HERE
 
 Existing Python Support
 -----------------------
 
 It may be that you have specific device support written in Python that you wish
 to expose as PVs. This could be either in the form of a device support library
 or using a Python library to calculate PV values as above.
-
-ADD THE FURKA/GRIMSEL MONITORING IOC USE CASE HERE

docs/how-to/use-asyncio-in-an-ioc.rst

@@ -12,7 +12,7 @@ an IOC.
 .. literalinclude:: ../examples/example_asyncio_ioc.py
 
 
-The ``dispatcher`` is created and passed to :func:`~softioc.softioc.iocInit`. This is what 
+The ``dispatcher`` is created and passed to :func:`~softioc.softioc.iocInit`. This is what
 allows the use of `asyncio` functions in this IOC. It contains a new event loop to handle
 this.
 
@@ -21,13 +21,14 @@ sleeping that coroutine between updates.
 Note that we run this coroutine in the ``loop`` of the ``dispatcher``, and not in the
 main event loop.
 
-This IOC will, like the one in `../tutorials/creating-an-ioc`, leave an interactive 
-shell open. The values of the PVs can be queried using the methods defined in the 
+This IOC will, like the one in `../tutorials/creating-an-ioc`, leave an interactive
+shell open. The values of the PVs can be queried using the methods defined in the
 `softioc.softioc` module.
 
 
 Asynchronous Channel Access
 ---------------------------
 
-PVs can be retrieved externally from a PV in an asynchronous manner by using the :py`aioca` module. 
-It provides ``await``-able implementations of ``caget``, ``caput``, etc. See that module for more information.
+PVs can be retrieved externally from a PV in an asynchronous manner by using the
+`aioca` module. It provides ``await``-able implementations of ``caget``,
+``caput``, etc. See that module for more information.

docs/index.rst

@@ -5,7 +5,7 @@ How the documentation is structured
 -----------------------------------
 
 Documentation is split into four categories, accessible from links below or in
-the side-bar. Use the links below or in the side-bar.
+the side-bar.
 
 .. rst-class:: columns
 

docs/tutorials/creating-an-ioc.rst

@@ -4,8 +4,8 @@ Creating an IOC
 Introduction
 ------------
 
-Once the module has been installed (see `installation`) we can create a 
-simple EPICS Input/Output Controller (IOC). 
+Once the module has been installed (see `installation`) we can create a
+simple EPICS Input/Output Controller (IOC).
 
 An EPICS IOC created with the help of ``pythonIoc`` and `softioc` is
 referred to as a "Python soft IOC".  The code below illustrates a simple IOC
@@ -19,30 +19,30 @@ Each section is explained in detail below:
     :start-after: # Import
     :end-before: # Set
 
-The `softioc` library is part of ``pythonIoc``. The two submodules 
-`softioc.softioc` and `softioc.builder` provide the basic 
+The `softioc` library is part of ``pythonIoc``. The two submodules
+`softioc.softioc` and `softioc.builder` provide the basic
 functionality for Python soft IOCs and are the ones that are normally used.
 
 `cothread` is one of the two possible libraries the IOC can use for
-asynchronous operations. 
+asynchronous operations.
 (see `../how-to/use-asyncio-in-an-ioc` for the alternative)
 
 
 
 .. literalinclude:: ../examples/example_cothread_ioc.py
-    :start-after: # Create 
+    :start-after: # Create
     :end-before: # Boilerplate
 
 PVs are normally created dynamically using `softioc.builder`.  All PV
-creation must be done before initialising the IOC. We define a lambda function for 
-`on_update` on ``ao`` such that whenever we set ``ao``, ``ai`` will be set to the 
-same value. The ``always_update`` flag ensures that the ``on_update`` function is always 
+creation must be done before initialising the IOC. We define a lambda function for
+`on_update` on ``ao`` such that whenever we set ``ao``, ``ai`` will be set to the
+same value. The ``always_update`` flag ensures that the ``on_update`` function is always
 triggered, which is not the default behaviour if the updated value is the same as the
 current value.
 
 
 .. literalinclude:: ../examples/example_cothread_ioc.py
-    :start-after: # Boilerplate 
+    :start-after: # Boilerplate
     :end-before: # Start
 
 
@@ -52,14 +52,14 @@ which must be called in this order.  After calling
 :func:`~softioc.builder.LoadDatabase` it is no longer possible to create PVs.
 
 .. literalinclude:: ../examples/example_cothread_ioc.py
-    :start-after: # Start 
+    :start-after: # Start
     :end-before: # Finally
 
 We define a long-running operation that will increment the value of ``ai`` once per
-second. This is run as a background thread by `cothread`. 
+second. This is run in the background by `cothread`.
 
 .. literalinclude:: ../examples/example_cothread_ioc.py
-    :start-after: # Finally 
+    :start-after: # Finally
 
 Finally the application must refrain from exiting until the IOC is no longer
 needed.  The :func:`~softioc.softioc.interactive_ioc` runs a Python
@@ -69,7 +69,7 @@ internals of the IOC while it's running.  The alternative is to call something
 like :func:`cothread.WaitForQuit` or some other `cothread` blocking
 action.
 
-In this interpreter there is immediate access to methods defined in the 
+In this interpreter there is immediate access to methods defined in the
 `softioc.softioc` module. For example the :func:`~softioc.softioc.dbgf` function
 can be run to observe the increasing value of ``AI``::
 
@@ -79,15 +79,15 @@ can be run to observe the increasing value of ``AI``::
     DBF_DOUBLE:         37
 
 And the :func:`~softioc.softioc.dbpf` method allows data to be set and to observe
-the functionality of the lambda passed to ``on_update`` . We set the value on ``AO`` 
+the functionality of the lambda passed to ``on_update`` . We set the value on ``AO``
 and read the value on ``AI`` (exact values will vary based on time taken)::
 
     >>> dbgf("MY-DEVICE-PREFIX:AI")
     DBF_DOUBLE:         15
     >>> dbpf("MY-DEVICE-PREFIX:AO","999")
-    DBF_DOUBLE:         999       
+    DBF_DOUBLE:         999
     >>> dbgf("MY-DEVICE-PREFIX:AI")
-    DBF_DOUBLE:         1010   
+    DBF_DOUBLE:         1010
 
 
 Creating PVs