visus
/
teensy-sdfat
关注 1
点赞 0
派生 0
代码 工单 0 合并请求 0 版本发布 0 百科 动态
您最多选择25个主题 主题必须以字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
13 提交
1 分支
目录树: ce04bbd047
分支列表 标签列表
${ item.name }
创建分支 ${ searchTerm }
从 'ce04bbd047'
${ noResults }
teensy-sdfat/SdFat/utility/DigitalPin.h

661 行
23KB
原始文件 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 defined(VARIANT_MIGHTY)

  215. // Mighty Layout

  216. static const pin_map_t pinMap[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  249. };

  250. #elif defined(VARIANT_BOBUINO)

  251. // Bobuino Layout

  252. static const pin_map_t pinMap[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  285. };

  286. #elif defined(VARIANT_STANDARD)

  287. // Standard Layout

  288. static const pin_map_t pinMap[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  321. };

  322. #else  // VARIANT_MIGHTY

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

  324. #endif  // VARIANT_MIGHTY

  325. //------------------------------------------------------------------------------

  326. #elif defined(__AVR_ATmega32U4__)

  327. #ifdef CORE_TEENSY

  328. // Teensy 2.0

  329. static const pin_map_t pinMap[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  355. };

  356. //------------------------------------------------------------------------------

  357. #else  // CORE_TEENSY

  358. // Leonardo

  359. static const pin_map_t pinMap[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  390. };

  391. #endif  // CORE_TEENSY

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

  393. #elif defined(__AVR_AT90USB646__)\

  394. || defined(__AVR_AT90USB1286__)

  395. // Teensy++ 1.0 & 2.0

  396. static const pin_map_t pinMap[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  443. };

  444. //------------------------------------------------------------------------------

  445. #else  // CPU type

  446. #error unknown CPU type

  447. #endif  // CPU type

  448. //------------------------------------------------------------------------------

  449. /** count of pins */

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

  451. //==============================================================================

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

  453. void badPinNumber(void)

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

  455. //------------------------------------------------------------------------------

  456. /** Check for valid pin number

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

  458.  */

  459. static inline __attribute__((always_inline))

  460. void badPinCheck(uint8_t pin) {

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

  462.     badPinNumber();

  463.   }

  464. }

  465. //------------------------------------------------------------------------------

  466. /** fast write helper

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

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

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

  470.  */

  471. static inline __attribute__((always_inline))

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

  473.   uint8_t oldSREG;

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

  475.     oldSREG = SREG;

  476.     cli();

  477.   }

  478.   if (level) {

  479.     *address |= 1 << bit;

  480.   } else {

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

  482.   }

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

  484.     SREG = oldSREG;

  485.   }

  486. }

  487. //------------------------------------------------------------------------------

  488. /** read pin value

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

  490.  * @return value read

  491.  */

  492. static inline __attribute__((always_inline))

  493. bool fastDigitalRead(uint8_t pin) {

  494.   badPinCheck(pin);

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

  496. }

  497. //------------------------------------------------------------------------------

  498. /** toggle a pin

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

  500.  *

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

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

  503.  */

  504. static inline __attribute__((always_inline))

  505. void fastDigitalToggle(uint8_t pin) {

  506.   badPinCheck(pin);

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

  508.     // must write bit to high address port

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

  510.   } else {

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

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

  513.   }

  514. }

  515. //------------------------------------------------------------------------------

  516. /** Set pin value

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

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

  519.  */

  520. static inline __attribute__((always_inline))

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

  522.   badPinCheck(pin);

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

  524. }

  525. //------------------------------------------------------------------------------

  526. /** set pin mode

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

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

  529.  *

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

  531.  */

  532. static inline __attribute__((always_inline))

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

  534.   badPinCheck(pin);

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

  536. }

  537. 

  538. #endif  // __arm__

  539. //------------------------------------------------------------------------------

  540. /** set pin configuration

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

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

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

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

  545.  */

  546. static inline __attribute__((always_inline))

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

  548.   fastPinMode(pin, mode);

  549.   fastDigitalWrite(pin, level);

  550. }

  551. //==============================================================================

  552. /**

  553.  * @class DigitalPin

  554.  * @brief Fast digital port I/O

  555.  */

  556. template<uint8_t PinNumber>

  557. class DigitalPin {

  558.  public:

  559.   //----------------------------------------------------------------------------

  560.   /** Constructor */

  561.   DigitalPin() {}

  562.   //----------------------------------------------------------------------------

  563.   /** Constructor

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

  565.    */

  566.   explicit DigitalPin(bool pinMode) {

  567.     mode(pinMode);

  568.   }

  569.   //----------------------------------------------------------------------------

  570.   /** Constructor

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

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

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

  574.    */

  575.   DigitalPin(bool mode, bool level) {

  576.     config(mode, level);

  577.   }

  578.   //----------------------------------------------------------------------------

  579.   /** Asignment operator

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

  581.    *  pin's level low.

  582.    *

  583.    * @return This DigitalPin instance.

  584.    */

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

  586.     write(value);

  587.     return *this;

  588.   }

  589.   //----------------------------------------------------------------------------

  590.   /** Parenthesis operator

  591.    * @return Pin's level

  592.    */

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

  594.     return read();

  595.   }

  596.   //----------------------------------------------------------------------------

  597.   /** set pin configuration

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

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

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

  601.    */

  602.   inline __attribute__((always_inline))

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

  604.     fastPinConfig(PinNumber, mode, level);

  605.   }

  606.   //----------------------------------------------------------------------------

  607.   /**

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

  609.    */

  610.   inline __attribute__((always_inline))

  611.   void high() {

  612.     write(true);

  613.   }

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

  615.   /**

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

  617.    */

  618.   inline __attribute__((always_inline))

  619.   void low() {

  620.     write(false);

  621.   }

  622.   //----------------------------------------------------------------------------

  623.   /**

  624.    * Set pin mode

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

  626.    *

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

  628.    */

  629.   inline __attribute__((always_inline))

  630.   void mode(bool pinMode) {

  631.     fastPinMode(PinNumber, pinMode);

  632.   }

  633.   //----------------------------------------------------------------------------

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

  635.   inline __attribute__((always_inline))

  636.   bool read() const {

  637.     return fastDigitalRead(PinNumber);

  638.   }

  639.   //----------------------------------------------------------------------------

  640.   /** toggle a pin

  641.    *

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

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

  644.    */

  645.   inline __attribute__((always_inline))

  646.   void toggle() {

  647.     fastDigitalToggle(PinNumber);

  648.   }

  649.   //----------------------------------------------------------------------------

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

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

  652.    *  pin's level low.

  653.    */

  654.   inline __attribute__((always_inline))

  655.   void write(bool value) {

  656.     fastDigitalWrite(PinNumber, value);

  657.   }

  658. };

  659. #endif  // DigitalPin_h

  660. /** @} */