Fri, 17 Nov 2017 10:13:31 +0100
proper configuration, homing and planner optimization
2 | 1 | /* Tone.cpp |
2 | ||
3 | A Tone Generator Library | |
4 | ||
5 | Written by Brett Hagman | |
6 | ||
7 | This library is free software; you can redistribute it and/or | |
8 | modify it under the terms of the GNU Lesser General Public | |
9 | License as published by the Free Software Foundation; either | |
10 | version 2.1 of the License, or (at your option) any later version. | |
11 | ||
12 | This library is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 | Lesser General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU Lesser General Public | |
18 | License along with this library; if not, write to the Free Software | |
19 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
20 | ||
21 | Version Modified By Date Comments | |
22 | ------- ----------- -------- -------- | |
23 | 0001 B Hagman 09/08/02 Initial coding | |
24 | 0002 B Hagman 09/08/18 Multiple pins | |
25 | 0003 B Hagman 09/08/18 Moved initialization from constructor to begin() | |
26 | 0004 B Hagman 09/09/26 Fixed problems with ATmega8 | |
27 | 0005 B Hagman 09/11/23 Scanned prescalars for best fit on 8 bit timers | |
28 | 09/11/25 Changed pin toggle method to XOR | |
29 | 09/11/25 Fixed timer0 from being excluded | |
30 | 0006 D Mellis 09/12/29 Replaced objects with functions | |
31 | 0007 M Sproul 10/08/29 Changed #ifdefs from cpu to register | |
32 | *************************************************/ | |
33 | ||
34 | #include <avr/interrupt.h> | |
35 | #include <avr/pgmspace.h> | |
36 | #include "Arduino.h" | |
37 | #include "pins_arduino.h" | |
38 | ||
39 | #if defined(__AVR_ATmega8__) || defined(__AVR_ATmega128__) | |
40 | #define TCCR2A TCCR2 | |
41 | #define TCCR2B TCCR2 | |
42 | #define COM2A1 COM21 | |
43 | #define COM2A0 COM20 | |
44 | #define OCR2A OCR2 | |
45 | #define TIMSK2 TIMSK | |
46 | #define OCIE2A OCIE2 | |
47 | #define TIMER2_COMPA_vect TIMER2_COMP_vect | |
48 | #define TIMSK1 TIMSK | |
49 | #endif | |
50 | ||
51 | // timerx_toggle_count: | |
52 | // > 0 - duration specified | |
53 | // = 0 - stopped | |
54 | // < 0 - infinitely (until stop() method called, or new play() called) | |
55 | ||
56 | #if !defined(__AVR_ATmega8__) | |
57 | volatile long timer0_toggle_count; | |
58 | volatile uint8_t *timer0_pin_port; | |
59 | volatile uint8_t timer0_pin_mask; | |
60 | #endif | |
61 | ||
62 | volatile long timer1_toggle_count; | |
63 | volatile uint8_t *timer1_pin_port; | |
64 | volatile uint8_t timer1_pin_mask; | |
65 | volatile long timer2_toggle_count; | |
66 | volatile uint8_t *timer2_pin_port; | |
67 | volatile uint8_t timer2_pin_mask; | |
68 | ||
69 | #if defined(TIMSK3) | |
70 | volatile long timer3_toggle_count; | |
71 | volatile uint8_t *timer3_pin_port; | |
72 | volatile uint8_t timer3_pin_mask; | |
73 | #endif | |
74 | ||
75 | #if defined(TIMSK4) | |
76 | volatile long timer4_toggle_count; | |
77 | volatile uint8_t *timer4_pin_port; | |
78 | volatile uint8_t timer4_pin_mask; | |
79 | #endif | |
80 | ||
81 | #if defined(TIMSK5) | |
82 | volatile long timer5_toggle_count; | |
83 | volatile uint8_t *timer5_pin_port; | |
84 | volatile uint8_t timer5_pin_mask; | |
85 | #endif | |
86 | ||
87 | ||
88 | // MLS: This does not make sense, the 3 options are the same | |
89 | #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) | |
90 | ||
91 | #define AVAILABLE_TONE_PINS 1 | |
92 | ||
93 | const uint8_t PROGMEM tone_pin_to_timer_PGM[] = { 2 /*, 3, 4, 5, 1, 0 */ }; | |
94 | static uint8_t tone_pins[AVAILABLE_TONE_PINS] = { 255 /*, 255, 255, 255, 255, 255 */ }; | |
95 | ||
96 | #elif defined(__AVR_ATmega8__) | |
97 | ||
98 | #define AVAILABLE_TONE_PINS 1 | |
99 | ||
100 | const uint8_t PROGMEM tone_pin_to_timer_PGM[] = { 2 /*, 1 */ }; | |
101 | static uint8_t tone_pins[AVAILABLE_TONE_PINS] = { 255 /*, 255 */ }; | |
102 | ||
103 | #else | |
104 | ||
105 | #define AVAILABLE_TONE_PINS 1 | |
106 | ||
107 | // Leave timer 0 to last. | |
108 | const uint8_t PROGMEM tone_pin_to_timer_PGM[] = { 2 /*, 1, 0 */ }; | |
109 | static uint8_t tone_pins[AVAILABLE_TONE_PINS] = { 255 /*, 255, 255 */ }; | |
110 | ||
111 | #endif | |
112 | ||
113 | ||
114 | ||
115 | static int8_t toneBegin(uint8_t _pin) | |
116 | { | |
117 | int8_t _timer = -1; | |
118 | ||
119 | // if we're already using the pin, the timer should be configured. | |
120 | for (int i = 0; i < AVAILABLE_TONE_PINS; i++) { | |
121 | if (tone_pins[i] == _pin) { | |
122 | return pgm_read_byte(tone_pin_to_timer_PGM + i); | |
123 | } | |
124 | } | |
125 | ||
126 | // search for an unused timer. | |
127 | for (int i = 0; i < AVAILABLE_TONE_PINS; i++) { | |
128 | if (tone_pins[i] == 255) { | |
129 | tone_pins[i] = _pin; | |
130 | _timer = pgm_read_byte(tone_pin_to_timer_PGM + i); | |
131 | break; | |
132 | } | |
133 | } | |
134 | ||
135 | if (_timer != -1) | |
136 | { | |
137 | // Set timer specific stuff | |
138 | // All timers in CTC mode | |
139 | // 8 bit timers will require changing prescalar values, | |
140 | // whereas 16 bit timers are set to either ck/1 or ck/64 prescalar | |
141 | switch (_timer) | |
142 | { | |
143 | #if defined(TCCR0A) && defined(TCCR0B) | |
144 | case 0: | |
145 | // 8 bit timer | |
146 | TCCR0A = 0; | |
147 | TCCR0B = 0; | |
148 | bitWrite(TCCR0A, WGM01, 1); | |
149 | bitWrite(TCCR0B, CS00, 1); | |
150 | timer0_pin_port = portOutputRegister(digitalPinToPort(_pin)); | |
151 | timer0_pin_mask = digitalPinToBitMask(_pin); | |
152 | break; | |
153 | #endif | |
154 | ||
155 | #if defined(TCCR1A) && defined(TCCR1B) && defined(WGM12) | |
156 | case 1: | |
157 | // 16 bit timer | |
158 | TCCR1A = 0; | |
159 | TCCR1B = 0; | |
160 | bitWrite(TCCR1B, WGM12, 1); | |
161 | bitWrite(TCCR1B, CS10, 1); | |
162 | timer1_pin_port = portOutputRegister(digitalPinToPort(_pin)); | |
163 | timer1_pin_mask = digitalPinToBitMask(_pin); | |
164 | break; | |
165 | #endif | |
166 | ||
167 | #if defined(TCCR2A) && defined(TCCR2B) | |
168 | case 2: | |
169 | // 8 bit timer | |
170 | TCCR2A = 0; | |
171 | TCCR2B = 0; | |
172 | bitWrite(TCCR2A, WGM21, 1); | |
173 | bitWrite(TCCR2B, CS20, 1); | |
174 | timer2_pin_port = portOutputRegister(digitalPinToPort(_pin)); | |
175 | timer2_pin_mask = digitalPinToBitMask(_pin); | |
176 | break; | |
177 | #endif | |
178 | ||
179 | #if defined(TCCR3A) && defined(TCCR3B) && defined(TIMSK3) | |
180 | case 3: | |
181 | // 16 bit timer | |
182 | TCCR3A = 0; | |
183 | TCCR3B = 0; | |
184 | bitWrite(TCCR3B, WGM32, 1); | |
185 | bitWrite(TCCR3B, CS30, 1); | |
186 | timer3_pin_port = portOutputRegister(digitalPinToPort(_pin)); | |
187 | timer3_pin_mask = digitalPinToBitMask(_pin); | |
188 | break; | |
189 | #endif | |
190 | ||
191 | #if defined(TCCR4A) && defined(TCCR4B) && defined(TIMSK4) | |
192 | case 4: | |
193 | // 16 bit timer | |
194 | TCCR4A = 0; | |
195 | TCCR4B = 0; | |
196 | #if defined(WGM42) | |
197 | bitWrite(TCCR4B, WGM42, 1); | |
198 | #elif defined(CS43) | |
199 | #warning this may not be correct | |
200 | // atmega32u4 | |
201 | bitWrite(TCCR4B, CS43, 1); | |
202 | #endif | |
203 | bitWrite(TCCR4B, CS40, 1); | |
204 | timer4_pin_port = portOutputRegister(digitalPinToPort(_pin)); | |
205 | timer4_pin_mask = digitalPinToBitMask(_pin); | |
206 | break; | |
207 | #endif | |
208 | ||
209 | #if defined(TCCR5A) && defined(TCCR5B) && defined(TIMSK5) | |
210 | case 5: | |
211 | // 16 bit timer | |
212 | TCCR5A = 0; | |
213 | TCCR5B = 0; | |
214 | bitWrite(TCCR5B, WGM52, 1); | |
215 | bitWrite(TCCR5B, CS50, 1); | |
216 | timer5_pin_port = portOutputRegister(digitalPinToPort(_pin)); | |
217 | timer5_pin_mask = digitalPinToBitMask(_pin); | |
218 | break; | |
219 | #endif | |
220 | } | |
221 | } | |
222 | ||
223 | return _timer; | |
224 | } | |
225 | ||
226 | ||
227 | ||
228 | // frequency (in hertz) and duration (in milliseconds). | |
229 | ||
230 | void tone(uint8_t _pin, unsigned int frequency, unsigned long duration) | |
231 | { | |
232 | uint8_t prescalarbits = 0b001; | |
233 | long toggle_count = 0; | |
234 | uint32_t ocr = 0; | |
235 | int8_t _timer; | |
236 | ||
237 | _timer = toneBegin(_pin); | |
238 | ||
239 | if (_timer >= 0) | |
240 | { | |
241 | // Set the pinMode as OUTPUT | |
242 | pinMode(_pin, OUTPUT); | |
243 | ||
244 | // if we are using an 8 bit timer, scan through prescalars to find the best fit | |
245 | if (_timer == 0 || _timer == 2) | |
246 | { | |
247 | ocr = F_CPU / frequency / 2 - 1; | |
248 | prescalarbits = 0b001; // ck/1: same for both timers | |
249 | if (ocr > 255) | |
250 | { | |
251 | ocr = F_CPU / frequency / 2 / 8 - 1; | |
252 | prescalarbits = 0b010; // ck/8: same for both timers | |
253 | ||
254 | if (_timer == 2 && ocr > 255) | |
255 | { | |
256 | ocr = F_CPU / frequency / 2 / 32 - 1; | |
257 | prescalarbits = 0b011; | |
258 | } | |
259 | ||
260 | if (ocr > 255) | |
261 | { | |
262 | ocr = F_CPU / frequency / 2 / 64 - 1; | |
263 | prescalarbits = _timer == 0 ? 0b011 : 0b100; | |
264 | ||
265 | if (_timer == 2 && ocr > 255) | |
266 | { | |
267 | ocr = F_CPU / frequency / 2 / 128 - 1; | |
268 | prescalarbits = 0b101; | |
269 | } | |
270 | ||
271 | if (ocr > 255) | |
272 | { | |
273 | ocr = F_CPU / frequency / 2 / 256 - 1; | |
274 | prescalarbits = _timer == 0 ? 0b100 : 0b110; | |
275 | if (ocr > 255) | |
276 | { | |
277 | // can't do any better than /1024 | |
278 | ocr = F_CPU / frequency / 2 / 1024 - 1; | |
279 | prescalarbits = _timer == 0 ? 0b101 : 0b111; | |
280 | } | |
281 | } | |
282 | } | |
283 | } | |
284 | ||
285 | #if defined(TCCR0B) | |
286 | if (_timer == 0) | |
287 | { | |
288 | TCCR0B = prescalarbits; | |
289 | } | |
290 | else | |
291 | #endif | |
292 | #if defined(TCCR2B) | |
293 | { | |
294 | TCCR2B = prescalarbits; | |
295 | } | |
296 | #else | |
297 | { | |
298 | // dummy place holder to make the above ifdefs work | |
299 | } | |
300 | #endif | |
301 | } | |
302 | else | |
303 | { | |
304 | // two choices for the 16 bit timers: ck/1 or ck/64 | |
305 | ocr = F_CPU / frequency / 2 - 1; | |
306 | ||
307 | prescalarbits = 0b001; | |
308 | if (ocr > 0xffff) | |
309 | { | |
310 | ocr = F_CPU / frequency / 2 / 64 - 1; | |
311 | prescalarbits = 0b011; | |
312 | } | |
313 | ||
314 | if (_timer == 1) | |
315 | { | |
316 | #if defined(TCCR1B) | |
317 | TCCR1B = (TCCR1B & 0b11111000) | prescalarbits; | |
318 | #endif | |
319 | } | |
320 | #if defined(TCCR3B) | |
321 | else if (_timer == 3) | |
322 | TCCR3B = (TCCR3B & 0b11111000) | prescalarbits; | |
323 | #endif | |
324 | #if defined(TCCR4B) | |
325 | else if (_timer == 4) | |
326 | TCCR4B = (TCCR4B & 0b11111000) | prescalarbits; | |
327 | #endif | |
328 | #if defined(TCCR5B) | |
329 | else if (_timer == 5) | |
330 | TCCR5B = (TCCR5B & 0b11111000) | prescalarbits; | |
331 | #endif | |
332 | ||
333 | } | |
334 | ||
335 | ||
336 | // Calculate the toggle count | |
337 | if (duration > 0) | |
338 | { | |
339 | toggle_count = 2 * frequency * duration / 1000; | |
340 | } | |
341 | else | |
342 | { | |
343 | toggle_count = -1; | |
344 | } | |
345 | ||
346 | // Set the OCR for the given timer, | |
347 | // set the toggle count, | |
348 | // then turn on the interrupts | |
349 | switch (_timer) | |
350 | { | |
351 | ||
352 | #if defined(OCR0A) && defined(TIMSK0) && defined(OCIE0A) | |
353 | case 0: | |
354 | OCR0A = ocr; | |
355 | timer0_toggle_count = toggle_count; | |
356 | bitWrite(TIMSK0, OCIE0A, 1); | |
357 | break; | |
358 | #endif | |
359 | ||
360 | case 1: | |
361 | #if defined(OCR1A) && defined(TIMSK1) && defined(OCIE1A) | |
362 | OCR1A = ocr; | |
363 | timer1_toggle_count = toggle_count; | |
364 | bitWrite(TIMSK1, OCIE1A, 1); | |
365 | #elif defined(OCR1A) && defined(TIMSK) && defined(OCIE1A) | |
366 | // this combination is for at least the ATmega32 | |
367 | OCR1A = ocr; | |
368 | timer1_toggle_count = toggle_count; | |
369 | bitWrite(TIMSK, OCIE1A, 1); | |
370 | #endif | |
371 | break; | |
372 | ||
373 | #if defined(OCR2A) && defined(TIMSK2) && defined(OCIE2A) | |
374 | case 2: | |
375 | OCR2A = ocr; | |
376 | timer2_toggle_count = toggle_count; | |
377 | bitWrite(TIMSK2, OCIE2A, 1); | |
378 | break; | |
379 | #endif | |
380 | ||
381 | #if defined(TIMSK3) | |
382 | case 3: | |
383 | OCR3A = ocr; | |
384 | timer3_toggle_count = toggle_count; | |
385 | bitWrite(TIMSK3, OCIE3A, 1); | |
386 | break; | |
387 | #endif | |
388 | ||
389 | #if defined(TIMSK4) | |
390 | case 4: | |
391 | OCR4A = ocr; | |
392 | timer4_toggle_count = toggle_count; | |
393 | bitWrite(TIMSK4, OCIE4A, 1); | |
394 | break; | |
395 | #endif | |
396 | ||
397 | #if defined(OCR5A) && defined(TIMSK5) && defined(OCIE5A) | |
398 | case 5: | |
399 | OCR5A = ocr; | |
400 | timer5_toggle_count = toggle_count; | |
401 | bitWrite(TIMSK5, OCIE5A, 1); | |
402 | break; | |
403 | #endif | |
404 | ||
405 | } | |
406 | } | |
407 | } | |
408 | ||
409 | ||
410 | // XXX: this function only works properly for timer 2 (the only one we use | |
411 | // currently). for the others, it should end the tone, but won't restore | |
412 | // proper PWM functionality for the timer. | |
413 | void disableTimer(uint8_t _timer) | |
414 | { | |
415 | switch (_timer) | |
416 | { | |
417 | case 0: | |
418 | #if defined(TIMSK0) | |
419 | TIMSK0 = 0; | |
420 | #elif defined(TIMSK) | |
421 | TIMSK = 0; // atmega32 | |
422 | #endif | |
423 | break; | |
424 | ||
425 | #if defined(TIMSK1) && defined(OCIE1A) | |
426 | case 1: | |
427 | bitWrite(TIMSK1, OCIE1A, 0); | |
428 | break; | |
429 | #endif | |
430 | ||
431 | case 2: | |
432 | #if defined(TIMSK2) && defined(OCIE2A) | |
433 | bitWrite(TIMSK2, OCIE2A, 0); // disable interrupt | |
434 | #endif | |
435 | #if defined(TCCR2A) && defined(WGM20) | |
436 | TCCR2A = (1 << WGM20); | |
437 | #endif | |
438 | #if defined(TCCR2B) && defined(CS22) | |
439 | TCCR2B = (TCCR2B & 0b11111000) | (1 << CS22); | |
440 | #endif | |
441 | #if defined(OCR2A) | |
442 | OCR2A = 0; | |
443 | #endif | |
444 | break; | |
445 | ||
446 | #if defined(TIMSK3) | |
447 | case 3: | |
448 | TIMSK3 = 0; | |
449 | break; | |
450 | #endif | |
451 | ||
452 | #if defined(TIMSK4) | |
453 | case 4: | |
454 | TIMSK4 = 0; | |
455 | break; | |
456 | #endif | |
457 | ||
458 | #if defined(TIMSK5) | |
459 | case 5: | |
460 | TIMSK5 = 0; | |
461 | break; | |
462 | #endif | |
463 | } | |
464 | } | |
465 | ||
466 | ||
467 | void noTone(uint8_t _pin) | |
468 | { | |
469 | int8_t _timer = -1; | |
470 | ||
471 | for (int i = 0; i < AVAILABLE_TONE_PINS; i++) { | |
472 | if (tone_pins[i] == _pin) { | |
473 | _timer = pgm_read_byte(tone_pin_to_timer_PGM + i); | |
474 | tone_pins[i] = 255; | |
475 | } | |
476 | } | |
477 | ||
478 | disableTimer(_timer); | |
479 | ||
480 | digitalWrite(_pin, 0); | |
481 | } | |
482 | ||
483 | #if 0 | |
484 | #if !defined(__AVR_ATmega8__) | |
485 | ISR(TIMER0_COMPA_vect) | |
486 | { | |
487 | if (timer0_toggle_count != 0) | |
488 | { | |
489 | // toggle the pin | |
490 | *timer0_pin_port ^= timer0_pin_mask; | |
491 | ||
492 | if (timer0_toggle_count > 0) | |
493 | timer0_toggle_count--; | |
494 | } | |
495 | else | |
496 | { | |
497 | disableTimer(0); | |
498 | *timer0_pin_port &= ~(timer0_pin_mask); // keep pin low after stop | |
499 | } | |
500 | } | |
501 | #endif | |
502 | ||
503 | ||
504 | ISR(TIMER1_COMPA_vect) | |
505 | { | |
506 | if (timer1_toggle_count != 0) | |
507 | { | |
508 | // toggle the pin | |
509 | *timer1_pin_port ^= timer1_pin_mask; | |
510 | ||
511 | if (timer1_toggle_count > 0) | |
512 | timer1_toggle_count--; | |
513 | } | |
514 | else | |
515 | { | |
516 | disableTimer(1); | |
517 | *timer1_pin_port &= ~(timer1_pin_mask); // keep pin low after stop | |
518 | } | |
519 | } | |
520 | #endif | |
521 | ||
522 | ||
523 | ISR(TIMER2_COMPA_vect) | |
524 | { | |
525 | ||
526 | if (timer2_toggle_count != 0) | |
527 | { | |
528 | // toggle the pin | |
529 | *timer2_pin_port ^= timer2_pin_mask; | |
530 | ||
531 | if (timer2_toggle_count > 0) | |
532 | timer2_toggle_count--; | |
533 | } | |
534 | else | |
535 | { | |
536 | // need to call noTone() so that the tone_pins[] entry is reset, so the | |
537 | // timer gets initialized next time we call tone(). | |
538 | // XXX: this assumes timer 2 is always the first one used. | |
539 | noTone(tone_pins[0]); | |
540 | // disableTimer(2); | |
541 | // *timer2_pin_port &= ~(timer2_pin_mask); // keep pin low after stop | |
542 | } | |
543 | } | |
544 | ||
545 | ||
546 | ||
547 | //#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) | |
548 | #if 0 | |
549 | ||
550 | ISR(TIMER3_COMPA_vect) | |
551 | { | |
552 | if (timer3_toggle_count != 0) | |
553 | { | |
554 | // toggle the pin | |
555 | *timer3_pin_port ^= timer3_pin_mask; | |
556 | ||
557 | if (timer3_toggle_count > 0) | |
558 | timer3_toggle_count--; | |
559 | } | |
560 | else | |
561 | { | |
562 | disableTimer(3); | |
563 | *timer3_pin_port &= ~(timer3_pin_mask); // keep pin low after stop | |
564 | } | |
565 | } | |
566 | ||
567 | ISR(TIMER4_COMPA_vect) | |
568 | { | |
569 | if (timer4_toggle_count != 0) | |
570 | { | |
571 | // toggle the pin | |
572 | *timer4_pin_port ^= timer4_pin_mask; | |
573 | ||
574 | if (timer4_toggle_count > 0) | |
575 | timer4_toggle_count--; | |
576 | } | |
577 | else | |
578 | { | |
579 | disableTimer(4); | |
580 | *timer4_pin_port &= ~(timer4_pin_mask); // keep pin low after stop | |
581 | } | |
582 | } | |
583 | ||
584 | ISR(TIMER5_COMPA_vect) | |
585 | { | |
586 | if (timer5_toggle_count != 0) | |
587 | { | |
588 | // toggle the pin | |
589 | *timer5_pin_port ^= timer5_pin_mask; | |
590 | ||
591 | if (timer5_toggle_count > 0) | |
592 | timer5_toggle_count--; | |
593 | } | |
594 | else | |
595 | { | |
596 | disableTimer(5); | |
597 | *timer5_pin_port &= ~(timer5_pin_mask); // keep pin low after stop | |
598 | } | |
599 | } | |
600 | ||
601 | #endif |