visus
/
teensy-sdfat
Observar 1
Favorito 0
Fork 0
Código Issues 0 Pull requests 0 Versões 0 Wiki Atividade
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
7 Commits
1 Branch
Tag: 2e8eeb8434
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de 2e8eeb8434
${ noResults }
teensy-sdfat/SdFat/utility/DigitalPin.h

654 linhas
23KB
Original Anotar Histórico 

  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) {pinMode(pin, mode);}

  85. #else  // __arm__

  86. #include <avr/io.h>

  87. #include <util/atomic.h>

  88. //------------------------------------------------------------------------------

  89. /**

  90.  * @class pin_map_t

  91.  * @brief struct for mapping digital pins

  92.  */

  93. struct pin_map_t {

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

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

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

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

  98. };

  99. //------------------------------------------------------------------------------

  100. #if defined(__AVR_ATmega168__)\

  101. ||defined(__AVR_ATmega168P__)\

  102. ||defined(__AVR_ATmega328P__)

  103. // 168 and 328 Arduinos

  104. const static pin_map_t pinMap[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  125. };

  126. //------------------------------------------------------------------------------

  127. #elif defined(__AVR_ATmega1280__)\

  128. || defined(__AVR_ATmega2560__)

  129. // Mega

  130. static const pin_map_t pinMap[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  201. };

  202. //------------------------------------------------------------------------------

  203. #elif defined(__AVR_ATmega1284P__)\

  204. || defined(__AVR_ATmega1284__)\

  205. || defined(__AVR_ATmega644P__)\

  206. || defined(__AVR_ATmega644__)\

  207. || defined(__AVR_ATmega64__)\

  208. || defined(__AVR_ATmega32__)\

  209. || defined(__AVR_ATmega324__)\

  210. || defined(__AVR_ATmega16__)

  211. 

  212. #ifdef defined(VARIANT_MIGHTY)

  213. // Mighty Layout

  214. static const pin_map_t pinMap[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  247. };

  248. #elif defined(VARIANT_BOBUINO)

  249. // Bobuino Layout

  250. static const pin_map_t pinMap[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  283. };

  284. #elif defined(VARIANT_STANDARD)

  285. // Standard Layout

  286. static const pin_map_t pinMap[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  319. };

  320. #else  // VARIANT_MIGHTY

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

  322. #endif  // VARIANT_MIGHTY

  323. //------------------------------------------------------------------------------

  324. #elif defined(__AVR_ATmega32U4__)

  325. #ifdef CORE_TEENSY

  326. // Teensy 2.0

  327. static const pin_map_t pinMap[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  353. };

  354. //------------------------------------------------------------------------------

  355. #else  // CORE_TEENSY

  356. // Leonardo

  357. static const pin_map_t pinMap[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  388. };

  389. #endif  // CORE_TEENSY

  390. //------------------------------------------------------------------------------

  391. #elif defined(__AVR_AT90USB646__)\

  392. || defined(__AVR_AT90USB1286__)

  393. // Teensy++ 1.0 & 2.0

  394. static const pin_map_t pinMap[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  441. };

  442. //------------------------------------------------------------------------------

  443. #else  // CPU type

  444. #error unknown CPU type

  445. #endif  // CPU type

  446. //------------------------------------------------------------------------------

  447. /** count of pins */

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

  449. //==============================================================================

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

  451. void badPinNumber(void)

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

  453. //------------------------------------------------------------------------------

  454. /** Check for valid pin number

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

  456.  */

  457. static inline __attribute__((always_inline))

  458. void badPinCheck(uint8_t pin) {

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

  460.      badPinNumber();

  461.   }

  462. }

  463. //------------------------------------------------------------------------------

  464. /** fast write helper

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

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

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

  468.  */

  469. static inline __attribute__((always_inline))

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

  471.   uint8_t oldSREG;

  472.   if (address > (uint8_t*)0X5F) {

  473.     oldSREG = SREG;

  474.     cli();

  475.   }

  476.   if (level) {

  477.     *address |= 1 << bit;

  478.   } else {

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

  480.   }

  481.   if (address > (uint8_t*)0X5F) {

  482.     SREG = oldSREG;

  483.   }

  484. }

  485. //------------------------------------------------------------------------------

  486. /** read pin value

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

  488.  * @return value read

  489.  */

  490. static inline __attribute__((always_inline))

  491. bool fastDigitalRead(uint8_t pin) {

  492.   badPinCheck(pin);

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

  494. }

  495. //------------------------------------------------------------------------------

  496. /** toggle a pin

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

  498.  *

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

  500.  * If the pin is in input mode toggle the state of the 20K pullup.

  501.  */

  502. static inline __attribute__((always_inline))

  503. void fastDigitalToggle(uint8_t pin) {

  504.   badPinCheck(pin);

  505.     if (pinMap[pin].pin > (uint8_t*)0X5F) {

  506.       // must write bit to high address port

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

  508.     } else {

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

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

  511.     }

  512. }

  513. //------------------------------------------------------------------------------

  514. /** Set pin value

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

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

  517.  */

  518. static inline __attribute__((always_inline))

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

  520.   badPinCheck(pin);

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

  522. }

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

  524. /** set pin mode

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

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

  527.  *

  528.  * fastPinMode does not enable or disable the 20K pullup for input mode.

  529.  */

  530. static inline __attribute__((always_inline))

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

  532.   badPinCheck(pin);

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

  534. }

  535. 

  536. #endif  // __arm__

  537. //------------------------------------------------------------------------------

  538. /** set pin configuration

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

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

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

  542.  *                  If mode is input, enable or disable the pin's 20K pullup.

  543.  */

  544. static inline __attribute__((always_inline))

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

  546.   fastPinMode(pin, mode);

  547.   fastDigitalWrite(pin, level);

  548. }

  549. //==============================================================================

  550. /**

  551.  * @class DigitalPin

  552.  * @brief Fast digital port I/O

  553.  */

  554. template<uint8_t PinNumber>

  555. class DigitalPin {

  556.  public:

  557.   //----------------------------------------------------------------------------

  558.   /** Constructor */

  559.   DigitalPin() {}

  560.   //----------------------------------------------------------------------------

  561.   /** Constructor

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

  563.    */

  564.   explicit DigitalPin(bool pinMode) {

  565.     mode(pinMode);

  566.   }

  567.   //----------------------------------------------------------------------------

  568.   /** Constructor

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

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

  571.    *                  If mode is input, enable or disable the pin's 20K pullup.

  572.    */

  573.   DigitalPin(bool mode, bool level) {

  574.     config(mode, level);

  575.   }

  576.   //----------------------------------------------------------------------------

  577.   /** Asignment operator

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

  579.    *  pin's level low.

  580.    *

  581.    * @return This DigitalPin instance.

  582.    */

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

  584.     write(value);

  585.     return *this;

  586.   }

  587.   //----------------------------------------------------------------------------

  588.   /** Parenthesis operator

  589.    * @return Pin's level

  590.    */

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

  592.     return read();

  593.   }

  594.   //----------------------------------------------------------------------------

  595.   /** set pin configuration

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

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

  598.    *                  If mode is input, enable or disable the pin's 20K pullup.

  599.    */

  600.   inline __attribute__((always_inline))

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

  602.     fastPinConfig(PinNumber, mode, level);

  603.   }

  604.   //----------------------------------------------------------------------------

  605.   /**

  606.    * Set pin level high if output mode or enable 20K pullup if input mode.

  607.    */

  608.   inline __attribute__((always_inline))

  609.   void high() {write(true);}

  610.   //----------------------------------------------------------------------------

  611.   /**

  612.    * Set pin level low if output mode or disable 20K pullup if input mode.

  613.    */

  614.   inline __attribute__((always_inline))

  615.   void low() {write(false);}

  616.   //----------------------------------------------------------------------------

  617.   /**

  618.    * Set pin mode

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

  620.    *

  621.    * mode() does not enable or disable the 20K pullup for input mode.

  622.    */

  623.   inline __attribute__((always_inline))

  624.   void mode(bool pinMode) {

  625.     fastPinMode(PinNumber, pinMode);

  626.   }

  627.   //----------------------------------------------------------------------------

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

  629.   inline __attribute__((always_inline))

  630.   bool read() const {

  631.     return fastDigitalRead(PinNumber);

  632.   }

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

  634.   /** toggle a pin

  635.    *

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

  637.    * If the pin is in input mode toggle the state of the 20K pullup.

  638.    */

  639.   inline __attribute__((always_inline))

  640.   void toggle() {

  641.     fastDigitalToggle(PinNumber);

  642.   }

  643.   //----------------------------------------------------------------------------

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

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

  646.    *  pin's level low.

  647.    */

  648.   inline __attribute__((always_inline))

  649.   void write(bool value) {

  650.     fastDigitalWrite(PinNumber, value);

  651.   }

  652. };

  653. #endif  // DigitalPin_h

  654. /** @} */