mimxrt: Update the PWM and Encoder sections.

robert-hh · robert-hh · commit 26ea6cb2230f · 2021-10-14T14:32:45.000+02:00
diff --git a/docs/mimxrt/machine.PWM.rst b/docs/mimxrt/machine.PWM.rst
@@ -101,13 +101,15 @@ Methods
   :noindex:
 
    Modify settings for the PWM object.  See the above constructor for details
-   about the parameters.
+   about the parameters. Calling init() without any arguments restarts a stopped
+   FLEXPWM submodule or QTMR channel with the same parameters as before.
+   The restart latency is less than 10 µs and will start with a full cycle.
 
-.. method:: PWM.deinit([mask])
+.. method:: PWM.deinit()
   :noindex:
 
-   Stop the PWM of the respective FLEXPWM submodule or QTMR channel. If a mask is specified,
-   the bits of it designate the respective submodules or channels.
+   Stops the PWM of the respective FLEXPWM submodule or QTMR channel after the
+   actual cycle has been completed.
 
 .. method:: PWM.freq([value])
   :noindex:
diff --git a/docs/mimxrt/machine.QECNT.rst b/docs/mimxrt/machine.QECNT.rst
@@ -14,8 +14,8 @@ Example usage::
     from machine import Pin, Encoder
 
     qe = Encoder(Pin(0), Pin(1))    # create Quadrature Encoder object
-    qe.position()                   # get current counter values
-    qe.position(0)                  # Set all counters to 0
+    qe.value()                      # get current counter values
+    qe.value(0)                     # Set value and revolution to 0
     qe.init(cycles=128)             # Specify 128 cycles/revolution
     qe.init(index=Pin(3))           # Specify Pin 3 as Index pulse input
     qe.deinit()                     # turn off the Qudrature encoder
@@ -60,7 +60,6 @@ Constructors
         value up to init + cycles - 1, and then reset to the init value and increase
         the revolution counter by one. The default is: no cycles set. In that case the
         position counter overflows at 2**32 - 1.
-      - *init*\=value. Sets the init value. The defaults value is 0.
       - *compare*\=value. Sets a position counter compare value. When the counter matches
         this value, a callback function can called and the match output will get a high level.
 
@@ -78,20 +77,25 @@ Methods
    Stops the Encoder, disables interrupts and releases the resources used by the encoder. On
    Soft Reset, all instances of Encoder and Counter are deinitialized.
 
-.. method:: Encoder.position([value])
+.. method:: Encoder.value([value])
 
-   Get or set the current counters of the Encoder as unsigned integers, with the position
-   counter being a 32 bit item, and the revolution and difference counters being 16 bit
-   items.
+   Get or set the current position counter of the Encoder as unsigned 32 bit integer.
 
-   With no arguments the actual counter values are returned. If a cycles value is set,
-   the values are returned as a tuple consisting of the position counter, the
-   revolution counter and the difference of the position counter since
-   the previous reading. If a cycles values not set, the position is returned as an
-   48 bit unsigned integer of the total event count as **revolution \* 2\*\*32 + position**.
+   With no arguments the actual position counter value is returned.
 
-   With a single *value* argument the position counter is set to that value. If a cycles value
-   is set, the revolution counter and difference counter are cleared.
+   With a single *value* argument the position counter is set to that value and the
+   revolution counter is cleared.
+
+.. method:: Encoder.revolution([value])
+
+   Get or set the current revolution counter of the Encoder as signed 16 bit integer.
+
+   With no arguments the actual revolution counter value is returned.
+
+   With a single *value* argument the revolution counter is set to that value. The
+   position counter is not changed. A total position can be caluclated as
+   revolution() * cycles + position() + init. If the total position range is still
+   too small, you can create your own revolution counter using the irq() callback method.
 
 .. method:: Encoder.compare([value])
 
@@ -161,8 +165,8 @@ Example usage::
     from machine import Pin, Counter
 
     counter = Counter(Pin(0))             # create Counter object
-    counter.values()                      # get current counter value
-    counter.values(0)                     # Set all counters to 0
+    counter.value()                       # get current counter value
+    counter.value(0)                      # Set the counter to 0
     counter.deinit()                      # turn off the Counter
     counter.init(compare=1000)            # Set create a compare match event at count 1000
     counter.irq(Counter.COMPARE, handler) # Call the function handler at a compare match
@@ -214,13 +218,26 @@ Methods
    Stops the Counter, disables interrupts and releases the resources used by the encoder. On
    Soft Reset, all instances of Encoder and Counter are deinitialized.
 
-.. method:: Counter.count([value])
+.. method:: Counter.value([value])
 
-   Get or set the current counter value of the Counter. The value is returned as a unsigned 48 bit
-   integer.
+   Get or set the current event value of the Counter. The value is returned as an
+   unsigned 32 bit integer.
 
    With a single *value* argument the counter is set to that value.
 
+.. method:: Encoder.overflow([value])
+
+   Get or set the current revolution counter of the counter as signed 16 bit integer.
+   The value represents the overflow or underflow events of the 32bit basic counter.
+   A total count can be calculated as overflow() * 0x100000000 + count().
+   If the total count range is still too small, you can create your own overflow
+   counter using the irq() callback method.
+
+   With no arguments the actual overflow counter value is returned.
+
+   With a single *value* argument the overflow counter is set to that value. The
+   event counter is not changed.
+
 .. method:: Counter.compare([value])
 
    Get or set the counter compare value.
