1
2
3
4
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
|
.. highlight:: cpp
.. _timers:
Timers
======
There are four general purpose timers in the Maple microcontroller
that can be configured to generate periodic or delayed events with
minimal work done by the microcontroller. For example, the :ref:`PWM
<pwm>` channels can generate regular square-wave signals on specific
output pins without consuming extra clock cycles. By attaching
interrupt handlers to these channels (instead of just changing the
voltage on an external pin), more complex events can be scheduled.
.. contents:: Contents
:local:
Introduction
------------
.. _timers-prescale:
The four timers each have four separate compare channels. Each channel
has an associated 16-bit counter that can be configured with a 16-bit
prescaler and a 16-bit overflow value. The prescaler determines how
fast the counter changes, while the overflow value determines when it
gets reset.
The prescaler acts as a divider of the 72MHz system clock. That is,
with a prescaler of 1, the channel's counter increments with a
frequency of 72MHz, rolling over (passing the maximum 16-bit unsigned
integer value of 65,535) more than a thousand times a second. With a
prescaler of 7200, it has a frequency of (72/7200) MHz = 10 KHz,
rolling over approximately every 6.55 seconds.
The overflow value is the maximum value the counter will go up to. It
defaults to the full 65,535; smaller values will cause the counter to
reset to zero more frequently.
Whenever a channel's counter reaches its overflow value, an "update
event" interrupt is generated. You can configure the Maple to notify
you when this takes place, by registering an interrupt handler, which
is a function that will be called when the update event occurs.
libmaple Reference
------------------
The libmaple API for interacting with timers is documented at the
:ref:`HardwareTimer reference <lang-hardwaretimer>`.
Caveats
-------
.. _timers-pwm-conflicts:
**PWM Conflicts:** Because PWM functionality on a given pin depends on
the configuration of the timer and channel, you must chose your
channels carefully if you want to use both timer interrupts and PWM in
the same program. Refer to the following table to match up timer
channels and Maple header pin numbers:
.. _timers-pin-channel-map:
.. csv-table::
:header: Timer, Ch. 1 pin, Ch. 2 pin, Ch. 3 pin, Ch. 4 pin
``Timer1``, 6, 7, 8, --
``Timer2``, 2, 3, 1, 0
``Timer3``, 12, 11, 27, 28
``Timer4``, 5, 9, 14, 24
**Overhead:** there is some overhead associated with function and
interrupt calls (loading and unloading the stack, preparing state,
etc.) and this overhead can fudge your timing. Imperfect code
branching also means that, e.g., channel 1 interrupts may get called a
couple clock cycles sooner than a channel 4 interrupt, all other
configuration being the same.
.. compound::
**Jitter:** other interrupts (USB, Serial, SysTick, or other
timers) can and will get called before or during the timer
interrupt routines, causing pseudorandom delays and other
frustrations.
Disabling the USB port (by calling ``SerialUSB.end()``, or just
running off a battery) helps a lot, but then you lose the
auto-reset and communications functionality. This will require
that you put your Maple into :ref:`perpetual bootloader mode
<troubleshooting-perpetual-bootloader>` before uploading a new
program to it (or somehow causing your program to re-enable serial
over USB using :ref:`SerialUSB.begin() <lang-serialusb-begin>`).
Disabling SysTick with ``systick_disable()`` helps as well.
However, calling this function will break the ``micros()`` and
``millis()`` functions.
**General:** working with timers and interrupts can be tricky and hard
to debug; they are a somewhat "advanced" topic. Start simple, test
with :ref:`ASSERT() <language-assert>`, and don't try to do too much
in your interrupt handlers! Make sure that what you're trying to do in
a handler isn't going to block other interrupts from firing (e.g. USB,
Serial, SysTick) if those other interrupts are important for your
program.
SysTick Peripheral
------------------
The SysTick peripheral allows another, simple way to perform periodic
or delayed events. This separate timer does not conflict with any
other peripherals, but the associated 1kHz interrupt can jitter the
general purpose timer interrupts; this is clearly seen when running
VGA code, where the timing jitters are transformed into visual jags in
the image. The SysTick peripheral can be disabled by calling
``systick_disable()``, and re-enabled using ``systick_resume()``.
Code Examples
-------------
LED blink
^^^^^^^^^
::
#define LED_RATE 500000 // in microseconds; should give 0.5Hz toggles
void handler_led(void);
void setup()
{
// Set up the LED to blink
pinMode(BOARD_LED_PIN, OUTPUT);
// Setup Timer
Timer2.setChannel1Mode(TIMER_OUTPUTCOMPARE);
Timer2.setPeriod(LED_RATE); // in microseconds
Timer2.setCompare1(1); // overflow might be small
Timer2.attachCompare1Interrupt(handler_led);
}
void loop() {
// Nothing! It's all in the interrupts
}
void handler_led(void) {
toggleLED();
}
Racing Counters
^^^^^^^^^^^^^^^
::
void handler_count1(void);
void handler_count2(void);
int count1 = 0;
int count2 = 0;
void setup()
{
// Set up BUT for input
pinMode(BOARD_BUTTON_PIN, INPUT_PULLUP);
// Setup Counting Timers
Timer3.setChannel1Mode(TIMER_OUTPUTCOMPARE);
Timer4.setChannel1Mode(TIMER_OUTPUTCOMPARE);
Timer3.pause();
Timer4.pause();
Timer3.setCount(0);
Timer4.setCount(0);
Timer3.setOverflow(30000);
Timer4.setOverflow(30000);
Timer3.setCompare1(1000); // somewhere in the middle
Timer4.setCompare1(1000);
Timer3.attachCompare1Interrupt(handler1);
Timer4.attachCompare1Interrupt(handler2);
Timer3.resume();
Timer4.resume();
}
void loop() {
// Display the running counts
SerialUSB.print("Count 1: ");
SerialUSB.print(count1);
SerialUSB.print("\t\tCount 2: ");
SerialUSB.println(count2);
// Run... while BUT is held, pause Count2
for(int i = 0; i<1000; i++) {
if(digitalRead(BOARD_BUTTON_PIN)) {
Timer4.pause();
} else {
Timer4.resume();
}
delay(1);
}
}
void handler1(void) {
count1++;
}
void handler2(void) {
count2++;
}
|
