.. currentmodule:: machine .. _machine.TimerWiPy:

class TimerWiPy -- control hardware timers

.. note::

This class is a non-standard Timer implementation for the WiPy.
It is available simply as ``machine.Timer`` on the WiPy but is named in the
documentation below as ``machine.TimerWiPy`` to distinguish it from the
more general :ref:`machine.Timer <machine.Timer>` class.

Hardware timers deal with timing of periods and events. Timers are perhaps the most flexible and heterogeneous kind of hardware in MCUs and SoCs, differently greatly from a model to a model. MicroPython's Timer class defines a baseline operation of executing a callback with a given period (or once after some delay), and allow specific boards to define more non-standard behaviour (which thus won't be portable to other boards).

Constructors

.. class:: TimerWiPy(id, ...)

Construct a new timer object of the given id. Id of -1 constructs a virtual timer (if supported by a board).

Methods

.. method:: TimerWiPy.init(mode, *, width=16)

Initialise the timer. Example::

   tim.init(Timer.PERIODIC)             # periodic 16-bit timer
   tim.init(Timer.ONE_SHOT, width=32)   # one shot 32-bit timer

Keyword arguments:

 - ``mode`` can be one of:

   - ``TimerWiPy.ONE_SHOT`` - The timer runs once until the configured
     period of the channel expires.
   - ``TimerWiPy.PERIODIC`` - The timer runs periodically at the configured
     frequency of the channel.
   - ``TimerWiPy.PWM``      - Output a PWM signal on a pin.

 - ``width`` must be either 16 or 32 (bits). For really low frequencies < 5Hz
   (or large periods), 32-bit timers should be used. 32-bit mode is only available
   for ``ONE_SHOT`` AND ``PERIODIC`` modes.

.. method:: TimerWiPy.deinit()

Deinitialises the timer. Stops the timer, and disables the timer peripheral.

.. method:: TimerWiPy.channel(channel, **, freq, period, polarity=TimerWiPy.POSITIVE, duty_cycle=0)

If only a channel identifier passed, then a previously initialized channel object is returned (or None if there is no previous channel).

Otherwise, a TimerChannel object is initialized and returned.

The operating mode is the one configured to the Timer object that was used to create the channel.

channel if the width of the timer is 16-bit, then must be either TIMER.A, TIMER.B. If the width is 32-bit then it must be TIMER.A | TIMER.B.

Keyword only arguments:

 - ``freq`` sets the frequency in Hz.
 - ``period`` sets the period in microseconds.

 .. note::

    Either ``freq`` or ``period`` must be given, never both.

 - ``polarity`` this is applicable for ``PWM``, and defines the polarity of the duty cycle
 - ``duty_cycle`` only applicable to ``PWM``. It's a percentage (0.00-100.00). Since the WiPy
   doesn't support floating point numbers the duty cycle must be specified in the range 0-10000,
   where 10000 would represent 100.00, 5050 represents 50.50, and so on.

.. note::

  When the channel is in PWM mode, the corresponding pin is assigned automatically, therefore
  there's no need to assign the alternate function of the pin via the ``Pin`` class. The pins which
  support PWM functionality are the following:

  - ``GP24`` on Timer 0 channel A.
  - ``GP25`` on Timer 1 channel A.
  - ``GP9``  on Timer 2 channel B.
  - ``GP10`` on Timer 3 channel A.
  - ``GP11`` on Timer 3 channel B.

class TimerChannel --- setup a channel for a timer

Timer channels are used to generate/capture a signal using a timer.

TimerChannel objects are created using the Timer.channel() method.

Methods

.. method:: timerchannel.irq(*, trigger, priority=1, handler=None)

The behaviour of this callback is heavily dependent on the operating
mode of the timer channel:

    - If mode is ``TimerWiPy.PERIODIC`` the callback is executed periodically
      with the configured frequency or period.
    - If mode is ``TimerWiPy.ONE_SHOT`` the callback is executed once when
      the configured timer expires.
    - If mode is ``TimerWiPy.PWM`` the callback is executed when reaching the duty
      cycle value.

The accepted params are:

    - ``priority`` level of the interrupt. Can take values in the range 1-7.
      Higher values represent higher priorities.
    - ``handler`` is an optional function to be called when the interrupt is triggered.
    - ``trigger`` must be ``TimerWiPy.TIMEOUT`` when the operating mode is either ``TimerWiPy.PERIODIC`` or
      ``TimerWiPy.ONE_SHOT``. In the case that mode is ``TimerWiPy.PWM`` then trigger must be equal to
      ``TimerWiPy.MATCH``.

Note that callback handlers are hard interrupts, and the constraints described in :ref:`isr_rules`
apply when they are executed.

Returns a callback object.

.. method:: timerchannel.freq([value])

Get or set the timer channel frequency (in Hz).

.. method:: timerchannel.period([value])

Get or set the timer channel period (in microseconds).

.. method:: timerchannel.duty_cycle([value])

Get or set the duty cycle of the PWM signal. It's a percentage (0.00-100.00). Since the WiPy doesn't support floating point numbers the duty cycle must be specified in the range 0-10000, where 10000 would represent 100.00, 5050 represents 50.50, and so on.

Constants

.. data:: TimerWiPy.ONE_SHOT .. data:: TimerWiPy.PERIODIC

Timer operating mode.