Minor documentation improvements

Author: raacampbell

code/+vidrio/+AI/hardwareContinuousVoltage.m

@@ -65,7 +65,7 @@
         hTask.createAIVoltageChan(devName, physicalChannels, [], minVoltage, maxVoltage);
 
 
-        % * Configure the sampling rate and the number of samples
+        % * Configure the sampling rate and the size of the buffer in samples
         %   More details at: "help dabs.ni.daqmx.Task.cfgSampClkTiming"
         %   C equivalent - DAQmxCfgSampClkTiming
         %   http://zone.ni.com/reference/en-XX/help/370471AE-01/daqmxcfunc/daqmxcfgsampclktiming/

code/+vidrio/+AI/hardwareContinuousVoltageWithCallBack.m

@@ -25,6 +25,7 @@
     % Also see:
     % TMW DAQ Toolbox example: daqtoolbox.AI.analogInput_Continuous
     % ANSI C: DAQmx_ANSI_C_examples/AI/ContAcq-IntClk.c 
+    % vidrio.AI.hardwareContinuousVoltage (without a callback function)
 
 
     % Parameters for the acquisition (device and channels)
@@ -57,7 +58,7 @@
         hTask.createAIVoltageChan(devName, physicalChannels, [], minVoltage, maxVoltage);
 
 
-        % * Configure the sampling rate and the number of samples
+        % * Configure the sampling rate and the size of the buffer in samples
         %   More details at: "help dabs.ni.daqmx.Task.cfgSampClkTiming"
         %   C equivalent - DAQmxCfgSampClkTiming
         %   http://zone.ni.com/reference/en-XX/help/370471AE-01/daqmxcfunc/daqmxcfgsampclktiming/
@@ -80,7 +81,7 @@
         hTask.start
 
 
-       fprintf('Recoding data on %s. Close window to stop.\n', devName);
+       fprintf('Recording data on %s. Close window to stop.\n', devName);
 
 
 

code/+vidrio/+sync/readme.md

@@ -1,66 +1,73 @@
 # Synchronising DAQ operations across devices
 
 The examples in this folder relate to synchronising tasks. 
-It's assumed you're already familiar with the information in vidrio.mixed
-Also see ContinuousAI.c in the DAQmx_ANSI_C_examples directory
+It's assumed you're already familiar with the information in `vidrio.mixed`.
+Also see `ContinuousAI.c` in the DAQmx_ANSI_C_examples directory.
+The following demo uses the class `vidrio.sync.sine_AO_AI`, which just plays a sine wave out of AO0 on the target DAQ device.
 
-### One
+### 1. Starting two tasks at the same time
 Let's start two tasks at the same time on different DAQs from the command line.
 Hook up the AO0 lines of each DAQ to a scope then run:
 
 ```
 >> B=vidrio.sync.sine_AO_AI('Dev1');
 >> R=vidrio.sync.sine_AO_AI('Dev2');
->> B.startAcquisition;R.startAcquisition;
+>> B.startAcquisition; R.startAcquisition;
 ```
 
-Where 'Dev1' and 'Dev2' are your DAQ names.
-You should see two waveforms with a phase shift. 
-Trigger off the waveform on channel 1 of the scope and change the time scale to show about one cycle of the waveform. 
-Watch for a while. What do you notice?
+Where `'Dev1'` and `'Dev2'` are your DAQ names.
+You should see two waveforms with a phase shift, since they didn't start at the same instant. 
+Set up the scope to trigger off the waveform on channel 1 and change the time scale to show about one cycle of the waveform. 
+Watch for a while. See the phase shift?
 
 Stop the acquisition:
 
 ```
 >> B.stopAcquisition;R.stopAcquisition;
 ```
 
-Also see `vidrio.sync.phaseMonitor('Dev1','Dev2');`
+You can also use `vidrio.sync.phaseMonitor('Dev1','Dev2');` to monitor the phase of the two waveforms without a scope. 
+
 
-### Two
-Will this problem go away if start the two waveforms at exactly the same time?
-vidrio.sync.sine_AO_AI triggers the AO task from the AI task so we need to set this up to wait for a trigger:
+### 2. Triggering the tasks simultaneously
+Will the phase shift problem go away if start the two waveforms at exactly the same time?
+`vidrio.sync.sine_AO_AI` triggers the AO task from the AI task so we need to set this up to wait for a trigger:
 
-Set up triggers so nothing happens until 5V goes into PFI0
+Set up triggers so nothing happens until 5V goes into PFI0. 
+The tasks need to be stopped (see above) then you can run:
 
 ```
->> B.hAITask.cfgDigEdgeStartTrig('PFI0','DAQmx_Val_Rising'); R.hAITask.cfgDigEdgeStartTrig('PFI0','DAQmx_Val_Rising');
+>> B.hAITask.cfgDigEdgeStartTrig('PFI0','DAQmx_Val_Rising'); 
+>> R.hAITask.cfgDigEdgeStartTrig('PFI0','DAQmx_Val_Rising');
 ```
 
-Now wire up the rack so that the two PFI0 ports are connected. If using BNC, attach a T-piece to one.
+Note how we can configure the start trigger properties directlty on the two objects we have already created. 
+This is what is nice about object-oriented programming. 
+To use the triggers, wire up the rack so that the two PFI0 ports are connected. If using BNC, attach a T-piece to one.
+Then start the tasks:
 
 ```
 >> B.startAcquisition;R.startAcquisition;
 ```
 
-Nothing happens on the scope until you hook up PFI0 (e.g. with your T connector) to +5 (the breakout box provides this)
+Nothing happens on the scope until you hook up PFI0 (e.g. with your T connector) to +5 (the breakout box provides this).
 You can unplug the 5V line right away, it's only needed transiently for the trigger. 
+Of course you could also hook up PFI0 to a digital line and trigger it via MAX Test Panels or even set up a separate digital task in MATLAB. 
 
 What do you see on the scope? The waveforms should be in phase perfectly. Nice, huh?
-Keep watching. Ah.....
+Keep watching. Ah... They drift apart over time. 
 
 Stop the acquisition:
 ```
->> B.stopAcquisition;R.stopAcquisition;
+>> B.stopAcquisition; R.stopAcquisition;
 ```
 
-### Three
+### 3. Sync the clocks
 The clocks are drifting! 
 Clearly we need a *shared clock* between the boards.
 Each class is set up such that the AI task on that device uses the AO clock of the same device. 
 So all we need to do is have the AO clock of the DAQ in one class use the AO clock of the DAQ in the other class.
 
-
 If your cards are in a PXI chassis or linked by an RTSI cable then you simply tell DAQmx that one device should use the other's clock:
 
 
@@ -89,4 +96,6 @@ Wire up your DAQ remembering to use PF1 not digital port 1 on line 0.
 >> B.startAcquisition;R.startAcquisition;
 ```
 
-Nice synchronised waveforms!
+Nice synchronised waveforms!
+Note that the above only works when your two (or more) tasks need to run at the same rate. 
+For more see the [NI synchronisation white paper](http://www.ni.com/white-paper/11369/en/).

code/basicConcepts/simpleOOexample.m

@@ -71,7 +71,7 @@
     % For example, our simple scanning software (https://github.com/tenss/SimpleMScanner) contains
     % classes that inherit handle. 
     %
-    % For those already familiar with "references: objects that inherit handle return a *reference* 
+    % For those already familiar with "references": objects that inherit handle return a *reference* 
     % to the object after construction. So you can pass a copy of the reference to another function 
     % and have it modify it without creating a new copy of the object that controls the DAQ. 
     % The handle class also allows us to create notifiers and listeners: