visus
/
teensy-sdfat
Слідкувати 1
В обрані 0
Форк 0
Код Проблеми 0 Запити на злиття 0 Релізи 0 Вікі Активність
Ви не можете вибрати більше 25 тем Теми мають розпочинатися з літери або цифри, можуть містити дефіси (-) і не повинні перевищувати 35 символів.
15 Коміти
1 Гілка
Дерево: 43c44ac8c7
Гілки Теги
${ item.name }
Створити гілку ${ searchTerm }
з '43c44ac8c7'
${ noResults }
teensy-sdfat/SdFat/utility/DigitalPin.h

697 lines
26KB
Неформатований Blame Історія 

  1. /* Arduino DigitalIO Library

  2.  * Copyright (C) 2013 by William Greiman

  3.  *

  4.  * This file is part of the Arduino DigitalIO Library

  5.  *

  6.  * This Library is free software: you can redistribute it and/or modify

  7.  * it under the terms of the GNU General Public License as published by

  8.  * the Free Software Foundation, either version 3 of the License, or

  9.  * (at your option) any later version.

  10.  *

  11.  * This Library is distributed in the hope that it will be useful,

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  14.  * GNU General Public License for more details.

  15.  *

  16.  * You should have received a copy of the GNU General Public License

  17.  * along with the Arduino DigitalIO Library.  If not, see

  18.  * <http://www.gnu.org/licenses/>.

  19.  */

  20. /**

  21.  * @file

  22.  * @brief Fast Digital Pin functions

  23.  *

  24.  * @defgroup digitalPin Fast Pin I/O

  25.  * @details  Fast Digital I/O functions and template class.

  26.  * @{

  27.  */

  28. #ifndef DigitalPin_h

  29. #define DigitalPin_h

  30. #include <Arduino.h>

  31. #ifdef __arm__

  32. #ifdef CORE_TEENSY

  33. //------------------------------------------------------------------------------

  34. /** read pin value

  35.  * @param[in] pin Arduino pin number

  36.  * @return value read

  37.  */

  38. static inline __attribute__((always_inline))

  39. bool fastDigitalRead(uint8_t pin) {

  40.   return *portInputRegister(pin);

  41. }

  42. //------------------------------------------------------------------------------

  43. /** Set pin value

  44.  * @param[in] pin Arduino pin number

  45.  * @param[in] level value to write

  46.  */

  47. static inline __attribute__((always_inline))

  48. void fastDigitalWrite(uint8_t pin, bool value) {

  49.   if (value) {

  50.     *portSetRegister(pin) = 1;

  51.   } else {

  52.     *portClearRegister(pin) = 1;

  53.   }

  54. }

  55. #else  // CORE_TEENSY

  56. //------------------------------------------------------------------------------

  57. /** read pin value

  58.  * @param[in] pin Arduino pin number

  59.  * @return value read

  60.  */

  61. static inline __attribute__((always_inline))

  62. bool fastDigitalRead(uint8_t pin) {

  63.   return g_APinDescription[pin].pPort->PIO_PDSR & g_APinDescription[pin].ulPin;

  64. }

  65. //------------------------------------------------------------------------------

  66. /** Set pin value

  67.  * @param[in] pin Arduino pin number

  68.  * @param[in] level value to write

  69.  */

  70. static inline __attribute__((always_inline))

  71. void fastDigitalWrite(uint8_t pin, bool value) {

  72.   if (value) {

  73.     g_APinDescription[pin].pPort->PIO_SODR = g_APinDescription[pin].ulPin;

  74.   } else {

  75.     g_APinDescription[pin].pPort->PIO_CODR = g_APinDescription[pin].ulPin;

  76.   }

  77. }

  78. #endif  // CORE_TEENSY

  79. //------------------------------------------------------------------------------

  80. inline void fastDigitalToggle(uint8_t pin) {

  81.   fastDigitalWrite(pin, !fastDigitalRead(pin));

  82. }

  83. //------------------------------------------------------------------------------

  84. inline void fastPinMode(uint8_t pin, bool mode) {

  85.   pinMode(pin, mode);

  86. }

  87. #else  // __arm__

  88. #include <avr/io.h>

  89. #include <util/atomic.h>

  90. //------------------------------------------------------------------------------

  91. /**

  92.  * @class pin_map_t

  93.  * @brief struct for mapping digital pins

  94.  */

  95. struct pin_map_t {

  96.   volatile uint8_t* ddr;   /**< address of DDR for this pin */

  97.   volatile uint8_t* pin;   /**< address of PIN for this pin */

  98.   volatile uint8_t* port;  /**< address of PORT for this pin */

  99.   uint8_t bit;             /**< bit number for this pin */

  100. };

  101. //------------------------------------------------------------------------------

  102. #if defined(__AVR_ATmega168__)\

  103. ||defined(__AVR_ATmega168P__)\

  104. ||defined(__AVR_ATmega328P__)

  105. // 168 and 328 Arduinos

  106. static const pin_map_t pinMap[] = {

  107.   {&DDRD, &PIND, &PORTD, 0},  // D0  0

  108.   {&DDRD, &PIND, &PORTD, 1},  // D1  1

  109.   {&DDRD, &PIND, &PORTD, 2},  // D2  2

  110.   {&DDRD, &PIND, &PORTD, 3},  // D3  3

  111.   {&DDRD, &PIND, &PORTD, 4},  // D4  4

  112.   {&DDRD, &PIND, &PORTD, 5},  // D5  5

  113.   {&DDRD, &PIND, &PORTD, 6},  // D6  6

  114.   {&DDRD, &PIND, &PORTD, 7},  // D7  7

  115.   {&DDRB, &PINB, &PORTB, 0},  // B0  8

  116.   {&DDRB, &PINB, &PORTB, 1},  // B1  9

  117.   {&DDRB, &PINB, &PORTB, 2},  // B2 10

  118.   {&DDRB, &PINB, &PORTB, 3},  // B3 11

  119.   {&DDRB, &PINB, &PORTB, 4},  // B4 12

  120.   {&DDRB, &PINB, &PORTB, 5},  // B5 13

  121.   {&DDRC, &PINC, &PORTC, 0},  // C0 14

  122.   {&DDRC, &PINC, &PORTC, 1},  // C1 15

  123.   {&DDRC, &PINC, &PORTC, 2},  // C2 16

  124.   {&DDRC, &PINC, &PORTC, 3},  // C3 17

  125.   {&DDRC, &PINC, &PORTC, 4},  // C4 18

  126.   {&DDRC, &PINC, &PORTC, 5}   // C5 19

  127. };

  128. //------------------------------------------------------------------------------

  129. #elif defined(__AVR_ATmega1280__)\

  130. || defined(__AVR_ATmega2560__)

  131. // Mega

  132. static const pin_map_t pinMap[] = {

  133.   {&DDRE, &PINE, &PORTE, 0},  // E0  0

  134.   {&DDRE, &PINE, &PORTE, 1},  // E1  1

  135.   {&DDRE, &PINE, &PORTE, 4},  // E4  2

  136.   {&DDRE, &PINE, &PORTE, 5},  // E5  3

  137.   {&DDRG, &PING, &PORTG, 5},  // G5  4

  138.   {&DDRE, &PINE, &PORTE, 3},  // E3  5

  139.   {&DDRH, &PINH, &PORTH, 3},  // H3  6

  140.   {&DDRH, &PINH, &PORTH, 4},  // H4  7

  141.   {&DDRH, &PINH, &PORTH, 5},  // H5  8

  142.   {&DDRH, &PINH, &PORTH, 6},  // H6  9

  143.   {&DDRB, &PINB, &PORTB, 4},  // B4 10

  144.   {&DDRB, &PINB, &PORTB, 5},  // B5 11

  145.   {&DDRB, &PINB, &PORTB, 6},  // B6 12

  146.   {&DDRB, &PINB, &PORTB, 7},  // B7 13

  147.   {&DDRJ, &PINJ, &PORTJ, 1},  // J1 14

  148.   {&DDRJ, &PINJ, &PORTJ, 0},  // J0 15

  149.   {&DDRH, &PINH, &PORTH, 1},  // H1 16

  150.   {&DDRH, &PINH, &PORTH, 0},  // H0 17

  151.   {&DDRD, &PIND, &PORTD, 3},  // D3 18

  152.   {&DDRD, &PIND, &PORTD, 2},  // D2 19

  153.   {&DDRD, &PIND, &PORTD, 1},  // D1 20

  154.   {&DDRD, &PIND, &PORTD, 0},  // D0 21

  155.   {&DDRA, &PINA, &PORTA, 0},  // A0 22

  156.   {&DDRA, &PINA, &PORTA, 1},  // A1 23

  157.   {&DDRA, &PINA, &PORTA, 2},  // A2 24

  158.   {&DDRA, &PINA, &PORTA, 3},  // A3 25

  159.   {&DDRA, &PINA, &PORTA, 4},  // A4 26

  160.   {&DDRA, &PINA, &PORTA, 5},  // A5 27

  161.   {&DDRA, &PINA, &PORTA, 6},  // A6 28

  162.   {&DDRA, &PINA, &PORTA, 7},  // A7 29

  163.   {&DDRC, &PINC, &PORTC, 7},  // C7 30

  164.   {&DDRC, &PINC, &PORTC, 6},  // C6 31

  165.   {&DDRC, &PINC, &PORTC, 5},  // C5 32

  166.   {&DDRC, &PINC, &PORTC, 4},  // C4 33

  167.   {&DDRC, &PINC, &PORTC, 3},  // C3 34

  168.   {&DDRC, &PINC, &PORTC, 2},  // C2 35

  169.   {&DDRC, &PINC, &PORTC, 1},  // C1 36

  170.   {&DDRC, &PINC, &PORTC, 0},  // C0 37

  171.   {&DDRD, &PIND, &PORTD, 7},  // D7 38

  172.   {&DDRG, &PING, &PORTG, 2},  // G2 39

  173.   {&DDRG, &PING, &PORTG, 1},  // G1 40

  174.   {&DDRG, &PING, &PORTG, 0},  // G0 41

  175.   {&DDRL, &PINL, &PORTL, 7},  // L7 42

  176.   {&DDRL, &PINL, &PORTL, 6},  // L6 43

  177.   {&DDRL, &PINL, &PORTL, 5},  // L5 44

  178.   {&DDRL, &PINL, &PORTL, 4},  // L4 45

  179.   {&DDRL, &PINL, &PORTL, 3},  // L3 46

  180.   {&DDRL, &PINL, &PORTL, 2},  // L2 47

  181.   {&DDRL, &PINL, &PORTL, 1},  // L1 48

  182.   {&DDRL, &PINL, &PORTL, 0},  // L0 49

  183.   {&DDRB, &PINB, &PORTB, 3},  // B3 50

  184.   {&DDRB, &PINB, &PORTB, 2},  // B2 51

  185.   {&DDRB, &PINB, &PORTB, 1},  // B1 52

  186.   {&DDRB, &PINB, &PORTB, 0},  // B0 53

  187.   {&DDRF, &PINF, &PORTF, 0},  // F0 54

  188.   {&DDRF, &PINF, &PORTF, 1},  // F1 55

  189.   {&DDRF, &PINF, &PORTF, 2},  // F2 56

  190.   {&DDRF, &PINF, &PORTF, 3},  // F3 57

  191.   {&DDRF, &PINF, &PORTF, 4},  // F4 58

  192.   {&DDRF, &PINF, &PORTF, 5},  // F5 59

  193.   {&DDRF, &PINF, &PORTF, 6},  // F6 60

  194.   {&DDRF, &PINF, &PORTF, 7},  // F7 61

  195.   {&DDRK, &PINK, &PORTK, 0},  // K0 62

  196.   {&DDRK, &PINK, &PORTK, 1},  // K1 63

  197.   {&DDRK, &PINK, &PORTK, 2},  // K2 64

  198.   {&DDRK, &PINK, &PORTK, 3},  // K3 65

  199.   {&DDRK, &PINK, &PORTK, 4},  // K4 66

  200.   {&DDRK, &PINK, &PORTK, 5},  // K5 67

  201.   {&DDRK, &PINK, &PORTK, 6},  // K6 68

  202.   {&DDRK, &PINK, &PORTK, 7}   // K7 69

  203. };

  204. //------------------------------------------------------------------------------

  205. #elif defined(__AVR_ATmega1284P__)\

  206. || defined(__AVR_ATmega1284__)\

  207. || defined(__AVR_ATmega644P__)\

  208. || defined(__AVR_ATmega644__)\

  209. || defined(__AVR_ATmega64__)\

  210. || defined(__AVR_ATmega32__)\

  211. || defined(__AVR_ATmega324__)\

  212. || defined(__AVR_ATmega16__)

  213. 

  214. #ifdef PORT_D0

  215. // Newer version of 1284P

  216.  static const pin_map_t pinMap[] = { 

  217.   {PORT_TO_MODE(PORT_D0), PORT_TO_INPUT(PORT_D0), PORT_TO_OUTPUT(PORT_D0),  BIT_D0},

  218.   {PORT_TO_MODE(PORT_D1), PORT_TO_INPUT(PORT_D1), PORT_TO_OUTPUT(PORT_D1),  BIT_D1},

  219.   {PORT_TO_MODE(PORT_D2), PORT_TO_INPUT(PORT_D2), PORT_TO_OUTPUT(PORT_D2),  BIT_D2},

  220.   {PORT_TO_MODE(PORT_D3), PORT_TO_INPUT(PORT_D3), PORT_TO_OUTPUT(PORT_D3),  BIT_D3},

  221.   {PORT_TO_MODE(PORT_D4), PORT_TO_INPUT(PORT_D4), PORT_TO_OUTPUT(PORT_D4),  BIT_D4},

  222.   {PORT_TO_MODE(PORT_D5), PORT_TO_INPUT(PORT_D5), PORT_TO_OUTPUT(PORT_D5),  BIT_D5},

  223.   {PORT_TO_MODE(PORT_D6), PORT_TO_INPUT(PORT_D6), PORT_TO_OUTPUT(PORT_D6),  BIT_D6},

  224.   {PORT_TO_MODE(PORT_D7), PORT_TO_INPUT(PORT_D7), PORT_TO_OUTPUT(PORT_D7),  BIT_D7},

  225.   {PORT_TO_MODE(PORT_D8), PORT_TO_INPUT(PORT_D8), PORT_TO_OUTPUT(PORT_D8),  BIT_D8},

  226.   {PORT_TO_MODE(PORT_D9), PORT_TO_INPUT(PORT_D9), PORT_TO_OUTPUT(PORT_D9),  BIT_D9},

  227.   {PORT_TO_MODE(PORT_D10), PORT_TO_INPUT(PORT_D10), PORT_TO_OUTPUT(PORT_D10),  BIT_D10},

  228.   {PORT_TO_MODE(PORT_D11), PORT_TO_INPUT(PORT_D11), PORT_TO_OUTPUT(PORT_D11),  BIT_D11},

  229.   {PORT_TO_MODE(PORT_D12), PORT_TO_INPUT(PORT_D12), PORT_TO_OUTPUT(PORT_D12),  BIT_D12},

  230.   {PORT_TO_MODE(PORT_D13), PORT_TO_INPUT(PORT_D13), PORT_TO_OUTPUT(PORT_D13),  BIT_D13},

  231.   {PORT_TO_MODE(PORT_D14), PORT_TO_INPUT(PORT_D14), PORT_TO_OUTPUT(PORT_D14),  BIT_D14},

  232.   {PORT_TO_MODE(PORT_D15), PORT_TO_INPUT(PORT_D15), PORT_TO_OUTPUT(PORT_D15),  BIT_D15},

  233.   {PORT_TO_MODE(PORT_D16), PORT_TO_INPUT(PORT_D16), PORT_TO_OUTPUT(PORT_D16),  BIT_D16},

  234.   {PORT_TO_MODE(PORT_D17), PORT_TO_INPUT(PORT_D17), PORT_TO_OUTPUT(PORT_D17),  BIT_D17},

  235.   {PORT_TO_MODE(PORT_D18), PORT_TO_INPUT(PORT_D18), PORT_TO_OUTPUT(PORT_D18),  BIT_D18},

  236.   {PORT_TO_MODE(PORT_D19), PORT_TO_INPUT(PORT_D19), PORT_TO_OUTPUT(PORT_D19),  BIT_D19},

  237.   {PORT_TO_MODE(PORT_D20), PORT_TO_INPUT(PORT_D20), PORT_TO_OUTPUT(PORT_D20),  BIT_D20},

  238.   {PORT_TO_MODE(PORT_D21), PORT_TO_INPUT(PORT_D21), PORT_TO_OUTPUT(PORT_D21),  BIT_D21},

  239.   {PORT_TO_MODE(PORT_D22), PORT_TO_INPUT(PORT_D22), PORT_TO_OUTPUT(PORT_D22),  BIT_D22},

  240.   {PORT_TO_MODE(PORT_D23), PORT_TO_INPUT(PORT_D23), PORT_TO_OUTPUT(PORT_D23),  BIT_D23},

  241.   {PORT_TO_MODE(PORT_D24), PORT_TO_INPUT(PORT_D24), PORT_TO_OUTPUT(PORT_D24),  BIT_D24},

  242.   {PORT_TO_MODE(PORT_D25), PORT_TO_INPUT(PORT_D25), PORT_TO_OUTPUT(PORT_D25),  BIT_D25},

  243.   {PORT_TO_MODE(PORT_D26), PORT_TO_INPUT(PORT_D26), PORT_TO_OUTPUT(PORT_D26),  BIT_D26},

  244.   {PORT_TO_MODE(PORT_D27), PORT_TO_INPUT(PORT_D27), PORT_TO_OUTPUT(PORT_D27),  BIT_D27},

  245.   {PORT_TO_MODE(PORT_D28), PORT_TO_INPUT(PORT_D28), PORT_TO_OUTPUT(PORT_D28),  BIT_D28},

  246.   {PORT_TO_MODE(PORT_D29), PORT_TO_INPUT(PORT_D29), PORT_TO_OUTPUT(PORT_D29),  BIT_D29},

  247.   {PORT_TO_MODE(PORT_D30), PORT_TO_INPUT(PORT_D30), PORT_TO_OUTPUT(PORT_D30),  BIT_D30},

  248.   {PORT_TO_MODE(PORT_D31), PORT_TO_INPUT(PORT_D31), PORT_TO_OUTPUT(PORT_D31),  BIT_D31}

  249. };  

  250. #elif analogInputToDigitalPin(0)==24

  251. // Mighty Layout

  252. static const pin_map_t pinMap[] = {

  253.   {&DDRB, &PINB, &PORTB, 0},  // B0  0

  254.   {&DDRB, &PINB, &PORTB, 1},  // B1  1

  255.   {&DDRB, &PINB, &PORTB, 2},  // B2  2

  256.   {&DDRB, &PINB, &PORTB, 3},  // B3  3

  257.   {&DDRB, &PINB, &PORTB, 4},  // B4  4

  258.   {&DDRB, &PINB, &PORTB, 5},  // B5  5

  259.   {&DDRB, &PINB, &PORTB, 6},  // B6  6

  260.   {&DDRB, &PINB, &PORTB, 7},  // B7  7

  261.   {&DDRD, &PIND, &PORTD, 0},  // D0  8

  262.   {&DDRD, &PIND, &PORTD, 1},  // D1  9

  263.   {&DDRD, &PIND, &PORTD, 2},  // D2 10

  264.   {&DDRD, &PIND, &PORTD, 3},  // D3 11

  265.   {&DDRD, &PIND, &PORTD, 4},  // D4 12

  266.   {&DDRD, &PIND, &PORTD, 5},  // D5 13

  267.   {&DDRD, &PIND, &PORTD, 6},  // D6 14

  268.   {&DDRD, &PIND, &PORTD, 7},  // D7 15

  269.   {&DDRC, &PINC, &PORTC, 0},  // C0 16

  270.   {&DDRC, &PINC, &PORTC, 1},  // C1 17

  271.   {&DDRC, &PINC, &PORTC, 2},  // C2 18

  272.   {&DDRC, &PINC, &PORTC, 3},  // C3 19

  273.   {&DDRC, &PINC, &PORTC, 4},  // C4 20

  274.   {&DDRC, &PINC, &PORTC, 5},  // C5 21

  275.   {&DDRC, &PINC, &PORTC, 6},  // C6 22

  276.   {&DDRC, &PINC, &PORTC, 7},  // C7 23

  277.   {&DDRA, &PINA, &PORTA, 0},  // A0 24

  278.   {&DDRA, &PINA, &PORTA, 1},  // A1 25

  279.   {&DDRA, &PINA, &PORTA, 2},  // A2 26

  280.   {&DDRA, &PINA, &PORTA, 3},  // A3 27

  281.   {&DDRA, &PINA, &PORTA, 4},  // A4 28

  282.   {&DDRA, &PINA, &PORTA, 5},  // A5 29

  283.   {&DDRA, &PINA, &PORTA, 6},  // A6 30

  284.   {&DDRA, &PINA, &PORTA, 7}   // A7 31

  285. };

  286. #elif analogInputToDigitalPin(0)==21

  287. // Bobuino Layout

  288. static const pin_map_t pinMap[] = {

  289.   {&DDRD, &PIND, &PORTD, 0},  // D0  0

  290.   {&DDRD, &PIND, &PORTD, 1},  // D1  1

  291.   {&DDRD, &PIND, &PORTD, 2},  // D2  2

  292.   {&DDRD, &PIND, &PORTD, 3},  // D3  3

  293.   {&DDRB, &PINB, &PORTB, 0},  // B0  4

  294.   {&DDRB, &PINB, &PORTB, 1},  // B1  5

  295.   {&DDRB, &PINB, &PORTB, 2},  // B2  6

  296.   {&DDRB, &PINB, &PORTB, 3},  // B3  7

  297.   {&DDRD, &PIND, &PORTD, 5},  // D5  8

  298.   {&DDRD, &PIND, &PORTD, 6},  // D6  9

  299.   {&DDRB, &PINB, &PORTB, 4},  // B4 10

  300.   {&DDRB, &PINB, &PORTB, 5},  // B5 11

  301.   {&DDRB, &PINB, &PORTB, 6},  // B6 12

  302.   {&DDRB, &PINB, &PORTB, 7},  // B7 13

  303.   {&DDRA, &PINA, &PORTA, 7},  // A7 14

  304.   {&DDRA, &PINA, &PORTA, 6},  // A6 15

  305.   {&DDRA, &PINA, &PORTA, 5},  // A5 16

  306.   {&DDRA, &PINA, &PORTA, 4},  // A4 17

  307.   {&DDRA, &PINA, &PORTA, 3},  // A3 18

  308.   {&DDRA, &PINA, &PORTA, 2},  // A2 19

  309.   {&DDRA, &PINA, &PORTA, 1},  // A1 20

  310.   {&DDRA, &PINA, &PORTA, 0},  // A0 21

  311.   {&DDRC, &PINC, &PORTC, 0},  // C0 22

  312.   {&DDRC, &PINC, &PORTC, 1},  // C1 23

  313.   {&DDRC, &PINC, &PORTC, 2},  // C2 24

  314.   {&DDRC, &PINC, &PORTC, 3},  // C3 25

  315.   {&DDRC, &PINC, &PORTC, 4},  // C4 26

  316.   {&DDRC, &PINC, &PORTC, 5},  // C5 27

  317.   {&DDRC, &PINC, &PORTC, 6},  // C6 28

  318.   {&DDRC, &PINC, &PORTC, 7},  // C7 29

  319.   {&DDRD, &PIND, &PORTD, 4},  // D4 30

  320.   {&DDRD, &PIND, &PORTD, 7}   // D7 31

  321. };

  322. #elif analogInputToDigitalPin(0)==31

  323. // Standard Layout

  324. static const pin_map_t pinMap[] = {

  325.   {&DDRB, &PINB, &PORTB, 0},  // B0  0

  326.   {&DDRB, &PINB, &PORTB, 1},  // B1  1

  327.   {&DDRB, &PINB, &PORTB, 2},  // B2  2

  328.   {&DDRB, &PINB, &PORTB, 3},  // B3  3

  329.   {&DDRB, &PINB, &PORTB, 4},  // B4  4

  330.   {&DDRB, &PINB, &PORTB, 5},  // B5  5

  331.   {&DDRB, &PINB, &PORTB, 6},  // B6  6

  332.   {&DDRB, &PINB, &PORTB, 7},  // B7  7

  333.   {&DDRD, &PIND, &PORTD, 0},  // D0  8

  334.   {&DDRD, &PIND, &PORTD, 1},  // D1  9

  335.   {&DDRD, &PIND, &PORTD, 2},  // D2 10

  336.   {&DDRD, &PIND, &PORTD, 3},  // D3 11

  337.   {&DDRD, &PIND, &PORTD, 4},  // D4 12

  338.   {&DDRD, &PIND, &PORTD, 5},  // D5 13

  339.   {&DDRD, &PIND, &PORTD, 6},  // D6 14

  340.   {&DDRD, &PIND, &PORTD, 7},  // D7 15

  341.   {&DDRC, &PINC, &PORTC, 0},  // C0 16

  342.   {&DDRC, &PINC, &PORTC, 1},  // C1 17

  343.   {&DDRC, &PINC, &PORTC, 2},  // C2 18

  344.   {&DDRC, &PINC, &PORTC, 3},  // C3 19

  345.   {&DDRC, &PINC, &PORTC, 4},  // C4 20

  346.   {&DDRC, &PINC, &PORTC, 5},  // C5 21

  347.   {&DDRC, &PINC, &PORTC, 6},  // C6 22

  348.   {&DDRC, &PINC, &PORTC, 7},  // C7 23

  349.   {&DDRA, &PINA, &PORTA, 7},  // A7 24

  350.   {&DDRA, &PINA, &PORTA, 6},  // A6 25

  351.   {&DDRA, &PINA, &PORTA, 5},  // A5 26

  352.   {&DDRA, &PINA, &PORTA, 4},  // A4 27

  353.   {&DDRA, &PINA, &PORTA, 3},  // A3 28

  354.   {&DDRA, &PINA, &PORTA, 2},  // A2 29

  355.   {&DDRA, &PINA, &PORTA, 1},  // A1 30

  356.   {&DDRA, &PINA, &PORTA, 0}   // A0 31

  357. };

  358. #else  // VARIANT_MIGHTY

  359. #error Undefined variant 1284, 644, 324, 64, 32

  360. #endif  // VARIANT_MIGHTY

  361. //------------------------------------------------------------------------------

  362. #elif defined(__AVR_ATmega32U4__)

  363. #ifdef CORE_TEENSY

  364. // Teensy 2.0

  365. static const pin_map_t pinMap[] = {

  366.   {&DDRB, &PINB, &PORTB, 0},  // B0  0

  367.   {&DDRB, &PINB, &PORTB, 1},  // B1  1

  368.   {&DDRB, &PINB, &PORTB, 2},  // B2  2

  369.   {&DDRB, &PINB, &PORTB, 3},  // B3  3

  370.   {&DDRB, &PINB, &PORTB, 7},  // B7  4

  371.   {&DDRD, &PIND, &PORTD, 0},  // D0  5

  372.   {&DDRD, &PIND, &PORTD, 1},  // D1  6

  373.   {&DDRD, &PIND, &PORTD, 2},  // D2  7

  374.   {&DDRD, &PIND, &PORTD, 3},  // D3  8

  375.   {&DDRC, &PINC, &PORTC, 6},  // C6  9

  376.   {&DDRC, &PINC, &PORTC, 7},  // C7 10

  377.   {&DDRD, &PIND, &PORTD, 6},  // D6 11

  378.   {&DDRD, &PIND, &PORTD, 7},  // D7 12

  379.   {&DDRB, &PINB, &PORTB, 4},  // B4 13

  380.   {&DDRB, &PINB, &PORTB, 5},  // B5 14

  381.   {&DDRB, &PINB, &PORTB, 6},  // B6 15

  382.   {&DDRF, &PINF, &PORTF, 7},  // F7 16

  383.   {&DDRF, &PINF, &PORTF, 6},  // F6 17

  384.   {&DDRF, &PINF, &PORTF, 5},  // F5 18

  385.   {&DDRF, &PINF, &PORTF, 4},  // F4 19

  386.   {&DDRF, &PINF, &PORTF, 1},  // F1 20

  387.   {&DDRF, &PINF, &PORTF, 0},  // F0 21

  388.   {&DDRD, &PIND, &PORTD, 4},  // D4 22

  389.   {&DDRD, &PIND, &PORTD, 5},  // D5 23

  390.   {&DDRE, &PINE, &PORTE, 6}   // E6 24

  391. };

  392. //------------------------------------------------------------------------------

  393. #else  // CORE_TEENSY

  394. // Leonardo

  395. static const pin_map_t pinMap[] = {

  396.   {&DDRD, &PIND, &PORTD, 2},  // D2  0

  397.   {&DDRD, &PIND, &PORTD, 3},  // D3  1

  398.   {&DDRD, &PIND, &PORTD, 1},  // D1  2

  399.   {&DDRD, &PIND, &PORTD, 0},  // D0  3

  400.   {&DDRD, &PIND, &PORTD, 4},  // D4  4

  401.   {&DDRC, &PINC, &PORTC, 6},  // C6  5

  402.   {&DDRD, &PIND, &PORTD, 7},  // D7  6

  403.   {&DDRE, &PINE, &PORTE, 6},  // E6  7

  404.   {&DDRB, &PINB, &PORTB, 4},  // B4  8

  405.   {&DDRB, &PINB, &PORTB, 5},  // B5  9

  406.   {&DDRB, &PINB, &PORTB, 6},  // B6 10

  407.   {&DDRB, &PINB, &PORTB, 7},  // B7 11

  408.   {&DDRD, &PIND, &PORTD, 6},  // D6 12

  409.   {&DDRC, &PINC, &PORTC, 7},  // C7 13

  410.   {&DDRB, &PINB, &PORTB, 3},  // B3 14

  411.   {&DDRB, &PINB, &PORTB, 1},  // B1 15

  412.   {&DDRB, &PINB, &PORTB, 2},  // B2 16

  413.   {&DDRB, &PINB, &PORTB, 0},  // B0 17

  414.   {&DDRF, &PINF, &PORTF, 7},  // F7 18

  415.   {&DDRF, &PINF, &PORTF, 6},  // F6 19

  416.   {&DDRF, &PINF, &PORTF, 5},  // F5 20

  417.   {&DDRF, &PINF, &PORTF, 4},  // F4 21

  418.   {&DDRF, &PINF, &PORTF, 1},  // F1 22

  419.   {&DDRF, &PINF, &PORTF, 0},  // F0 23

  420.   {&DDRD, &PIND, &PORTD, 4},  // D4 24

  421.   {&DDRD, &PIND, &PORTD, 7},  // D7 25

  422.   {&DDRB, &PINB, &PORTB, 4},  // B4 26

  423.   {&DDRB, &PINB, &PORTB, 5},  // B5 27

  424.   {&DDRB, &PINB, &PORTB, 6},  // B6 28

  425.   {&DDRD, &PIND, &PORTD, 6}   // D6 29

  426. };

  427. #endif  // CORE_TEENSY

  428. //------------------------------------------------------------------------------

  429. #elif defined(__AVR_AT90USB646__)\

  430. || defined(__AVR_AT90USB1286__)

  431. // Teensy++ 1.0 & 2.0

  432. static const pin_map_t pinMap[] = {

  433.   {&DDRD, &PIND, &PORTD, 0},  // D0  0

  434.   {&DDRD, &PIND, &PORTD, 1},  // D1  1

  435.   {&DDRD, &PIND, &PORTD, 2},  // D2  2

  436.   {&DDRD, &PIND, &PORTD, 3},  // D3  3

  437.   {&DDRD, &PIND, &PORTD, 4},  // D4  4

  438.   {&DDRD, &PIND, &PORTD, 5},  // D5  5

  439.   {&DDRD, &PIND, &PORTD, 6},  // D6  6

  440.   {&DDRD, &PIND, &PORTD, 7},  // D7  7

  441.   {&DDRE, &PINE, &PORTE, 0},  // E0  8

  442.   {&DDRE, &PINE, &PORTE, 1},  // E1  9

  443.   {&DDRC, &PINC, &PORTC, 0},  // C0 10

  444.   {&DDRC, &PINC, &PORTC, 1},  // C1 11

  445.   {&DDRC, &PINC, &PORTC, 2},  // C2 12

  446.   {&DDRC, &PINC, &PORTC, 3},  // C3 13

  447.   {&DDRC, &PINC, &PORTC, 4},  // C4 14

  448.   {&DDRC, &PINC, &PORTC, 5},  // C5 15

  449.   {&DDRC, &PINC, &PORTC, 6},  // C6 16

  450.   {&DDRC, &PINC, &PORTC, 7},  // C7 17

  451.   {&DDRE, &PINE, &PORTE, 6},  // E6 18

  452.   {&DDRE, &PINE, &PORTE, 7},  // E7 19

  453.   {&DDRB, &PINB, &PORTB, 0},  // B0 20

  454.   {&DDRB, &PINB, &PORTB, 1},  // B1 21

  455.   {&DDRB, &PINB, &PORTB, 2},  // B2 22

  456.   {&DDRB, &PINB, &PORTB, 3},  // B3 23

  457.   {&DDRB, &PINB, &PORTB, 4},  // B4 24

  458.   {&DDRB, &PINB, &PORTB, 5},  // B5 25

  459.   {&DDRB, &PINB, &PORTB, 6},  // B6 26

  460.   {&DDRB, &PINB, &PORTB, 7},  // B7 27

  461.   {&DDRA, &PINA, &PORTA, 0},  // A0 28

  462.   {&DDRA, &PINA, &PORTA, 1},  // A1 29

  463.   {&DDRA, &PINA, &PORTA, 2},  // A2 30

  464.   {&DDRA, &PINA, &PORTA, 3},  // A3 31

  465.   {&DDRA, &PINA, &PORTA, 4},  // A4 32

  466.   {&DDRA, &PINA, &PORTA, 5},  // A5 33

  467.   {&DDRA, &PINA, &PORTA, 6},  // A6 34

  468.   {&DDRA, &PINA, &PORTA, 7},  // A7 35

  469.   {&DDRE, &PINE, &PORTE, 4},  // E4 36

  470.   {&DDRE, &PINE, &PORTE, 5},  // E5 37

  471.   {&DDRF, &PINF, &PORTF, 0},  // F0 38

  472.   {&DDRF, &PINF, &PORTF, 1},  // F1 39

  473.   {&DDRF, &PINF, &PORTF, 2},  // F2 40

  474.   {&DDRF, &PINF, &PORTF, 3},  // F3 41

  475.   {&DDRF, &PINF, &PORTF, 4},  // F4 42

  476.   {&DDRF, &PINF, &PORTF, 5},  // F5 43

  477.   {&DDRF, &PINF, &PORTF, 6},  // F6 44

  478.   {&DDRF, &PINF, &PORTF, 7}   // F7 45

  479. };

  480. //------------------------------------------------------------------------------

  481. #else  // CPU type

  482. #error unknown CPU type

  483. #endif  // CPU type

  484. //------------------------------------------------------------------------------

  485. /** count of pins */

  486. static const uint8_t digitalPinCount = sizeof(pinMap)/sizeof(pin_map_t);

  487. //==============================================================================

  488. /** generate bad pin number error */

  489. void badPinNumber(void)

  490. __attribute__((error("Pin number is too large or not a constant")));

  491. //------------------------------------------------------------------------------

  492. /** Check for valid pin number

  493.  * @param[in] pin Number of pin to be checked.

  494.  */

  495. static inline __attribute__((always_inline))

  496. void badPinCheck(uint8_t pin) {

  497.   if (!__builtin_constant_p(pin) || pin >= digitalPinCount) {

  498.     badPinNumber();

  499.   }

  500. }

  501. //------------------------------------------------------------------------------

  502. /** fast write helper

  503.  * @param[in] address I/O register address

  504.  * @param[in] bit bit number to write

  505.  * @param[in] level value for bit

  506.  */

  507. static inline __attribute__((always_inline))

  508. void fastBitWriteSafe(volatile uint8_t* address, uint8_t bit, bool level) {

  509.   uint8_t oldSREG;

  510.   if (address > reinterpret_cast<uint8_t*>(0X5F)) {

  511.     oldSREG = SREG;

  512.     cli();

  513.   }

  514.   if (level) {

  515.     *address |= 1 << bit;

  516.   } else {

  517.     *address &= ~(1 << bit);

  518.   }

  519.   if (address > reinterpret_cast<uint8_t*>(0X5F)) {

  520.     SREG = oldSREG;

  521.   }

  522. }

  523. //------------------------------------------------------------------------------

  524. /** read pin value

  525.  * @param[in] pin Arduino pin number

  526.  * @return value read

  527.  */

  528. static inline __attribute__((always_inline))

  529. bool fastDigitalRead(uint8_t pin) {

  530.   badPinCheck(pin);

  531.   return (*pinMap[pin].pin >> pinMap[pin].bit) & 1;

  532. }

  533. //------------------------------------------------------------------------------

  534. /** toggle a pin

  535.  * @param[in] pin Arduino pin number

  536.  *

  537.  * If the pin is in output mode toggle the pin level.

  538.  * If the pin is in input mode toggle the state of the 20K pull-up.

  539.  */

  540. static inline __attribute__((always_inline))

  541. void fastDigitalToggle(uint8_t pin) {

  542.   badPinCheck(pin);

  543.   if (pinMap[pin].pin > reinterpret_cast<uint8_t*>(0X5F)) {

  544.     // must write bit to high address port

  545.     *pinMap[pin].pin = 1 << pinMap[pin].bit;

  546.   } else {

  547.     // will compile to sbi and PIN register will not be read.

  548.     *pinMap[pin].pin |= 1 << pinMap[pin].bit;

  549.   }

  550. }

  551. //------------------------------------------------------------------------------

  552. /** Set pin value

  553.  * @param[in] pin Arduino pin number

  554.  * @param[in] level value to write

  555.  */

  556. static inline __attribute__((always_inline))

  557. void fastDigitalWrite(uint8_t pin, bool level) {

  558.   badPinCheck(pin);

  559.   fastBitWriteSafe(pinMap[pin].port, pinMap[pin].bit, level);

  560. }

  561. //------------------------------------------------------------------------------

  562. /** set pin mode

  563.  * @param[in] pin Arduino pin number

  564.  * @param[in] mode if true set output mode else input mode

  565.  *

  566.  * fastPinMode does not enable or disable the 20K pull-up for input mode.

  567.  */

  568. static inline __attribute__((always_inline))

  569. void fastPinMode(uint8_t pin, bool mode) {

  570.   badPinCheck(pin);

  571.   fastBitWriteSafe(pinMap[pin].ddr, pinMap[pin].bit, mode);

  572. }

  573. 

  574. #endif  // __arm__

  575. //------------------------------------------------------------------------------

  576. /** set pin configuration

  577.  * @param[in] pin Arduino pin number

  578.  * @param[in] mode If true set output mode else input mode

  579.  * @param[in] level If mode is output, set level high/low.

  580.  *                  If mode is input, enable or disable the pin's 20K pull-up.

  581.  */

  582. static inline __attribute__((always_inline))

  583. void fastPinConfig(uint8_t pin, bool mode, bool level) {

  584.   fastPinMode(pin, mode);

  585.   fastDigitalWrite(pin, level);

  586. }

  587. //==============================================================================

  588. /**

  589.  * @class DigitalPin

  590.  * @brief Fast digital port I/O

  591.  */

  592. template<uint8_t PinNumber>

  593. class DigitalPin {

  594.  public:

  595.   //----------------------------------------------------------------------------

  596.   /** Constructor */

  597.   DigitalPin() {}

  598.   //----------------------------------------------------------------------------

  599.   /** Constructor

  600.    * @param[in] pinMode if true set output mode else input mode.

  601.    */

  602.   explicit DigitalPin(bool pinMode) {

  603.     mode(pinMode);

  604.   }

  605.   //----------------------------------------------------------------------------

  606.   /** Constructor

  607.    * @param[in] mode If true set output mode else input mode

  608.    * @param[in] level If mode is output, set level high/low.

  609.    *                  If mode is input, enable or disable the pin's 20K pull-up.

  610.    */

  611.   DigitalPin(bool mode, bool level) {

  612.     config(mode, level);

  613.   }

  614.   //----------------------------------------------------------------------------

  615.   /** Asignment operator

  616.    * @param[in] value If true set the pin's level high else set the

  617.    *  pin's level low.

  618.    *

  619.    * @return This DigitalPin instance.

  620.    */

  621.   inline DigitalPin & operator = (bool value) __attribute__((always_inline)) {

  622.     write(value);

  623.     return *this;

  624.   }

  625.   //----------------------------------------------------------------------------

  626.   /** Parenthesis operator

  627.    * @return Pin's level

  628.    */

  629.   inline operator bool() const __attribute__((always_inline)) {

  630.     return read();

  631.   }

  632.   //----------------------------------------------------------------------------

  633.   /** set pin configuration

  634.    * @param[in] mode If true set output mode else input mode

  635.    * @param[in] level If mode is output, set level high/low.  If mode

  636.    *                  is input, enable or disable the pin's 20K pull-up.

  637.    */

  638.   inline __attribute__((always_inline))

  639.   void config(bool mode, bool level) {

  640.     fastPinConfig(PinNumber, mode, level);

  641.   }

  642.   //----------------------------------------------------------------------------

  643.   /**

  644.    * Set pin level high if output mode or enable 20K pull-up if input mode.

  645.    */

  646.   inline __attribute__((always_inline))

  647.   void high() {

  648.     write(true);

  649.   }

  650.   //----------------------------------------------------------------------------

  651.   /**

  652.    * Set pin level low if output mode or disable 20K pull-up if input mode.

  653.    */

  654.   inline __attribute__((always_inline))

  655.   void low() {

  656.     write(false);

  657.   }

  658.   //----------------------------------------------------------------------------

  659.   /**

  660.    * Set pin mode

  661.    * @param[in] pinMode if true set output mode else input mode.

  662.    *

  663.    * mode() does not enable or disable the 20K pull-up for input mode.

  664.    */

  665.   inline __attribute__((always_inline))

  666.   void mode(bool pinMode) {

  667.     fastPinMode(PinNumber, pinMode);

  668.   }

  669.   //----------------------------------------------------------------------------

  670.   /** @return Pin's level */

  671.   inline __attribute__((always_inline))

  672.   bool read() const {

  673.     return fastDigitalRead(PinNumber);

  674.   }

  675.   //----------------------------------------------------------------------------

  676.   /** toggle a pin

  677.    *

  678.    * If the pin is in output mode toggle the pin's level.

  679.    * If the pin is in input mode toggle the state of the 20K pull-up.

  680.    */

  681.   inline __attribute__((always_inline))

  682.   void toggle() {

  683.     fastDigitalToggle(PinNumber);

  684.   }

  685.   //----------------------------------------------------------------------------

  686.   /** Write the pin's level.

  687.    * @param[in] value If true set the pin's level high else set the

  688.    *  pin's level low.

  689.    */

  690.   inline __attribute__((always_inline))

  691.   void write(bool value) {

  692.     fastDigitalWrite(PinNumber, value);

  693.   }

  694. };

  695. #endif  // DigitalPin_h

  696. /** @} */