pyb.Timer.rst 9.24 KB
Newer Older
1
2
.. _pyb.Timer:

3
4
class Timer -- control internal timers
======================================
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234

Timers can be used for a great variety of tasks.  At the moment, only
the simplest case is implemented: that of calling a function periodically.

Each timer consists of a counter that counts up at a certain rate.  The rate
at which it counts is the peripheral clock frequency (in Hz) divided by the
timer prescaler.  When the counter reaches the timer period it triggers an
event, and the counter resets back to zero.  By using the callback method,
the timer event can call a Python function.

Example usage to toggle an LED at a fixed frequency::

    tim = pyb.Timer(4)              # create a timer object using timer 4
    tim.init(freq=2)                # trigger at 2Hz
    tim.callback(lambda t:pyb.LED(1).toggle())

Further examples::

    tim = pyb.Timer(4, freq=100)    # freq in Hz
    tim = pyb.Timer(4, prescaler=0, period=99)
    tim.counter()                   # get counter (can also set)
    tim.prescaler(2)                # set prescaler (can also get)
    tim.period(199)                 # set period (can also get)
    tim.callback(lambda t: ...)     # set callback for update interrupt (t=tim instance)
    tim.callback(None)              # clear callback

*Note:* Timer 3 is reserved for internal use.  Timer 5 controls
the servo driver, and Timer 6 is used for timed ADC/DAC reading/writing.
It is recommended to use the other timers in your programs.


Constructors
------------

.. class:: pyb.Timer(id, ...)

   Construct a new timer object of the given id.  If additional
   arguments are given, then the timer is initialised by ``init(...)``.
   ``id`` can be 1 to 14, excluding 3.


Methods
-------

.. method:: timer.callback(fun)

   Set the function to be called when the timer triggers.
   ``fun`` is passed 1 argument, the timer object.
   If ``fun`` is ``None`` then the callback will be disabled.

.. method:: timer.channel(channel, mode, ...)

   If only a channel number is passed, then a previously initialized channel
   object is returned (or ``None`` if there is no previous channel).
   
   Othwerwise, a TimerChannel object is initialized and returned.
   
   Each channel can be configured to perform pwm, output compare, or
   input capture. All channels share the same underlying timer, which means
   that they share the same timer clock.
   
   Keyword arguments:
   
     - ``mode`` can be one of:

       - ``Timer.PWM`` --- configure the timer in PWM mode (active high).
       - ``Timer.PWM_INVERTED`` --- configure the timer in PWM mode (active low).
       - ``Timer.OC_TIMING`` --- indicates that no pin is driven.
       - ``Timer.OC_ACTIVE`` --- the pin will be made active when a compare match occurs (active is determined by polarity)
       - ``Timer.OC_INACTIVE`` --- the pin will be made inactive when a compare match occurs.
       - ``Timer.OC_TOGGLE`` --- the pin will be toggled when an compare match occurs.
       - ``Timer.OC_FORCED_ACTIVE`` --- the pin is forced active (compare match is ignored).
       - ``Timer.OC_FORCED_INACTIVE`` --- the pin is forced inactive (compare match is ignored).
       - ``Timer.IC`` --- configure the timer in Input Capture mode.
   
     - ``callback`` - as per TimerChannel.callback()
   
     - ``pin`` None (the default) or a Pin object. If specified (and not None)
       this will cause the alternate function of the the indicated pin
       to be configured for this timer channel. An error will be raised if
       the pin doesn't support any alternate functions for this timer channel.
   
   Keyword arguments for Timer.PWM modes:
   
     - ``pulse_width`` - determines the initial pulse width value to use.
     - ``pulse_width_percent`` - determines the initial pulse width percentage to use.
   
   Keyword arguments for Timer.OC modes:
   
     - ``compare`` - determines the initial value of the compare register.
   
     - ``polarity`` can be one of:
       - ``Timer.HIGH`` - output is active high
       - ``Timer.LOW`` - output is acive low
   
   Optional keyword arguments for Timer.IC modes:
   
     - ``polarity`` can be one of:
       - ``Timer.RISING`` - captures on rising edge.
       - ``Timer.FALLING`` - captures on falling edge.
       - ``Timer.BOTH`` - captures on both edges.
   
     Note that capture only works on the primary channel, and not on the
     complimentary channels.
   
   PWM Example::
   
       timer = pyb.Timer(2, freq=1000)
       ch2 = timer.channel(2, pyb.Timer.PWM, pin=pyb.Pin.board.X2, pulse_width=210000)
       ch3 = timer.channel(3, pyb.Timer.PWM, pin=pyb.Pin.board.X3, pulse_width=420000)

.. method:: timer.counter([value])

   Get or set the timer counter.

.. method:: timer.deinit()

   Deinitialises the timer.
   
   Disables the callback (and the associated irq).
   Disables any channel callbacks (and the associated irq).
   Stops the timer, and disables the timer peripheral.

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

   Get or set the frequency for the timer (changes prescaler and period if set).

.. method:: timer.init(\*, freq, prescaler, period)

   Initialise the timer.  Initialisation must be either by frequency (in Hz)
   or by prescaler and period::
   
       tim.init(freq=100)                  # set the timer to trigger at 100Hz
       tim.init(prescaler=83, period=999)  # set the prescaler and period directly
   
   Keyword arguments:
   
     - ``freq`` --- specifies the periodic frequency of the timer. You migh also
       view this as the frequency with which the timer goes through one complete cycle.
   
     - ``prescaler`` [0-0xffff] - specifies the value to be loaded into the
       timer's Prescaler Register (PSC). The timer clock source is divided by
       (``prescaler + 1``) to arrive at the timer clock. Timers 2-7 and 12-14
       have a clock source of 84 MHz (pyb.freq()[2] \* 2), and Timers 1, and 8-11
       have a clock source of 168 MHz (pyb.freq()[3] \* 2).
   
     - ``period`` [0-0xffff] for timers 1, 3, 4, and 6-15. [0-0x3fffffff] for timers 2 & 5.
       Specifies the value to be loaded into the timer's AutoReload
       Register (ARR). This determines the period of the timer (i.e. when the
       counter cycles). The timer counter will roll-over after ``period + 1``
       timer clock cycles.
   
     - ``mode`` can be one of:

       - ``Timer.UP`` - configures the timer to count from 0 to ARR (default)
       - ``Timer.DOWN`` - configures the timer to count from ARR down to 0.
       - ``Timer.CENTER`` - confgures the timer to count from 0 to ARR and
         then back down to 0.
   
     - ``div`` can be one of 1, 2, or 4. Divides the timer clock to determine
       the sampling clock used by the digital filters.
   
     - ``callback`` - as per Timer.callback()
   
     - ``deadtime`` - specifies the amount of "dead" or inactive time between
       transitions on complimentary channels (both channels will be inactive)
       for this time). ``deadtime`` may be an integer between 0 and 1008, with
       the following restrictions: 0-128 in steps of 1. 128-256 in steps of
       2, 256-512 in steps of 8, and 512-1008 in steps of 16. ``deadime``
       measures ticks of ``source_freq`` divided by ``div`` clock ticks.
       ``deadtime`` is only available on timers 1 and 8.
   
    You must either specify freq or both of period and prescaler.

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

   Get or set the period of the timer.

.. method:: timer.prescaler([value])

   Get or set the prescaler for the timer.

.. method:: timer.source_freq()

   Get the frequency of the source of the timer.

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.callback(fun)

   Set the function to be called when the timer channel triggers.
   ``fun`` is passed 1 argument, the timer object.
   If ``fun`` is ``None`` then the callback will be disabled.

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

   Get or set the capture value associated with a channel.
   capture, compare, and pulse_width are all aliases for the same function.
   capture is the logical name to use when the channel is in input capture mode.

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

   Get or set the compare value associated with a channel.
   capture, compare, and pulse_width are all aliases for the same function.
   compare is the logical name to use when the channel is in output compare mode.

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

   Get or set the pulse width value associated with a channel.
   capture, compare, and pulse_width are all aliases for the same function.
   pulse_width is the logical name to use when the channel is in PWM mode.
   
   In edge aligned mode, a pulse_width of ``period + 1`` corresponds to a duty cycle of 100%
   In center aligned mode, a pulse width of ``period`` corresponds to a duty cycle of 100%

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

   Get or set the pulse width percentage associated with a channel.  The value
   is a number between 0 and 100 and sets the percentage of the timer period
   for which the pulse is active.  The value can be an integer or
   floating-point number for more accuracy.  For example, a value of 25 gives
   a duty cycle of 25%.