FYI: Port Manipulation Macros for the UNO

I always have to look up the port manipulation syntax for each pin so I made some macros that I can more easily remember.
These may be of interest to some.
SETd2
RESETd2
TOGGLEd2
TESTd2
etc.

// myUNOmacros.h
// Save this file into the C:\Users\YOURUSER\Documents\Arduino\libraries\ folder
// LarryD
//==============================================================
// These Macros can be used with UNO board
//
//
// ATMEL ATMEGA8 & 168/328  ARDUINO UNO
//
//                  +-\/-+
//            PC6  1|    |28  PC5 (AI 5)
//      (D 0) PD0  2|    |27  PC4 (AI 4)
//      (D 1) PD1  3|    |26  PC3 (AI 3)
//      (D 2) PD2  4|    |25  PC2 (AI 2)
// PWM+ (D 3) PD3  5|    |24  PC1 (AI 1)
//      (D 4) PD4  6|    |23  PC0 (AI 0)
//            VCC  7|    |22  GND
//            GND  8|    |21  AREF
//            PB6  9|    |20  AVCC
//            PB7 10|    |19  PB5 (D 13)
// PWM+ (D 5) PD5 11|    |18  PB4 (D 12)
// PWM+ (D 6) PD6 12|    |17  PB3 (D 11) PWM
//      (D 7) PD7 13|    |16  PB2 (D 10) PWM
//      (D 8) PB0 14|    |15  PB1 (D 9)  PWM
//                  +----+
//
// **************************************************************************** 
// Note: 
// PIND D0 to D7
// D0=0x01 D1=0x02 D2=0x04 D3=0x08 D4=0x10 D5=0x20 D6=0x40 D7=0x80
//
// PINB D8 to D13
// D8=0x01 D9=0x02 D10=0x04 D11=0x08 D12=0x10 D13=0x20  
//
// PINC D14 to D19
// D14=0x01 D15=0x02 D16=0x04 D17=0x08 D18=0x10 D19=0x20  
// **************************************************************************** 
//
//==============================================================
// Port D port pins 0-7
//                            DDDDDDDD
//                            76543210        
//#define SETd0       PORTD |= B00000001  // Pin D0 HIGH Shared with USB RX
//#define RESETd0     PORTD &= B11111110  // Pin D0 LOW Shared with USB TX
//#define TOGGLEd0    PIND   = B00000001  // Toggle digital pin D0 Shared with USB RX
//#define TESTd0      (PIND  & B00000001) // D0 is tested

//#define SETd0       PORTD |= B00000010  // Pin D1 HIGH Shared with USB RX
//#define RESETd0     PORTD &= B11111101  // Pin D1 LOW Shared with USB TX
//#define TOGGLEd1    PIND   = B00000010  // Toggle digital pin D1 Shared with USB TX
//#define TESTd1      (PIND  & B00000010) // D1 is tested

//                            DDDDDDDD
//                            76543210        
#define SETd2       PORTD |= B00000100  // D2 HIGH
#define RESETd2     PORTD &= B11111011  // D2 LOW
#define TOGGLEd2     PIND  = B00000100  // D2 Toggle
#define TESTd2      (PIND  & B00000100) // D2 is tested

#define SETd3       PORTD |= B00001000  // D3 HIGH
#define RESETd3     PORTD &= B11110111  // D3 LOW
#define TOGGLEd3     PIND  = B00001000  // D3 Toggle
#define TESTd3      (PIND  & B00001000) // D3 is tested

#define SETd4       PORTD |= B00010000  // D4 HIGH
#define RESETd4     PORTD &= B11101111  // D4 LOW
#define TOGGLEd4     PIND  = B00010000  // D4 Toggle   
#define TESTd4      (PIND  & B00010000) // D4 is tested


#define SETd5       PORTD |= B00100000  // D5 HIGH
#define RESETd5     PORTD &= B11011111  // D5 LOW
#define TOGGLEd5     PIND  = B00100000  // D5 Toggle 
#define TESTd5      (PIND  & B00100000) // D5 is tested

#define SETd6       PORTD |= B01000000  // D6 HIGH
#define RESETd6     PORTD &= B10111111  // D6 LOW
#define TOGGLEd6     PIND  = B01000000  // D6 Toggle  
#define TESTd6      (PIND  & B01000000) // D6 is tested

#define SETd7       PORTD |= B10000000  // D7 HIGH
#define RESETd7     PORTD &= B01111111  // D7 LOW
#define TOGGLEd7     PIND  = B10000000  // D7 Toggle  
#define TESTd7      (PIND  & B10000000) // D7 is tested

// Port B port pins 0-5
//                              DDDDDD
//                              111100 
//                              321098     
#define SETd8       PORTB  = B00000001  // D8 HIGH
#define RESETd8     PORTB &= B11111110  // D8 LOW
#define TOGGLEd8     PINB  = B00000001  // D8 Toggle
#define TESTd8      (PINB  & B00000001) // D8 is tested

#define SETd9       PORTB |= B00000010  // D9 HIGH
#define RESETd9     PORTB &= B11111101  // D9 LOW
#define TOGGLEd9     PINB  = B00000010  // D9 Toggle
#define TESTd9      (PINB  & B00000010) // D9 is tested

#define SETd10      PORTB |= B00000100  // D10 HIGH
#define RESETd10    PORTB &= B11111011  // D10 LOW
#define TOGGLEd10    PINB  = B00000100  // D10 Toggle
#define TESTd10     (PINB  & B00000100) // D10 is tested

#define SETd11      PORTB |= B00001000  // D11 HIGH
#define RESETd11    PORTB &= B11110111  // D11 LOW
#define TOGGLEd11    PINB  = B00001000  // D11 Toggle
#define TESTd11     (PINB  & B00001000) // D11 is tested

#define SETd12      PORTB |= B00010000  // D12 HIGH
#define RESETd12    PORTB &= B11101111  // D12 LOW
#define TOGGLEd12    PINB  = B00010000  // D12 Toggle
#define TESTd12     (PINB  & B00010000) // D12 is tested

#define SETd13      PORTB |= B00100000  // D13 HIGH
#define RESETd13    PORTB &= B11011111  // D13 LOW
#define TOGGLEd13    PINB  = B00100000  // D13 Toggle
#define TESTd13     (PINB  & B00100000) // D13 is tested


// Port C port pins 0-5
//                              DDDDDD
//                              111111
//                              987654     
#define SETd14      PORTC |= B00000001  // D14 HIGH
#define RESETd14    PORTC &= B11111110  // D14 LOW
#define TOGGLEd14    PINC  = B00000001  // D14 Toggle
#define TESTd14     (PINC  & B00000001) // D14 is tested

#define SETd15      PORTC |= B00000010  // D15 HIGH
#define RESETd15    PORTC &= B11111101  // D15 LOW
#define TOGGLEd15    PINC  = B00000010  // D15 Toggle
#define TESTd15     (PINC  & B00000010) // D15 is tested

#define SETd16      PORTC |= B00000100  // D16 HIGH
#define RESETd16    PORTC &= B11111011  // D16 LOW
#define TOGGLEd16    PINC  = B00000100  // D16 Toggle
#define TESTd16     (PINC  & B00000100) // D16 is tested

#define SETd17      PORTC |= B00001000  // D17 HIGH
#define RESETd17    PORTC &= B11110111  // D17 LOW
#define TOGGLEd17    PINC  = B00001000  // D17 Toggle
#define TESTd17     (PINC  & B00001000) // D17 is tested

#define SETd18      PORTC |= B00010000  // D18 HIGH
#define RESETd18    PORTC &= B11101111  // D18 LOW
#define TOGGLEd18    PINC  = B00010000  // D18 Toggle
#define TESTd18     (PINC  & B00010000) // D18 is tested

#define SETd19      PORTC |= B00100000  // D19 HIGH
#define RESETd19    PORTC &= B11011111  // D19 LOW
#define TOGGLEd19    PINC  = B00100000  // D19 Toggle
#define TESTd19     (PINC  & B00100000) // D19 is tested

Example:

// Macro testing

//the macros in the following file use direct port manipulation
//to handle digital pin operations 
#include <myUNOmacros.h>

const byte led = 13;
const byte button = 2;

void setup()
{                
  pinMode(led, OUTPUT);
  pinMode(button,INPUT_PULLUP);
}

void loop()
{
  if (TESTd2)  //tests to see if d2 is HIGH
  {
    TOGGLEd13; //toggles the state of d13
  }

  //tests to see if d2 is LOW
  //  if (!TESTd2) 
  //  {
  //    TOGGLEd13; //toggles the state of d13
  //  }

  //set d13 to a HIGH
  //  SETd13;       
  //  delay(100);
  //reset d13 to a LOW
  //  RESETd13;     

  //toggles the state of d13
  //  TOGGLEd13;    

  delay(100);
}
#define TOGGLEd2     PIND |= B00000100  // D2 Toggle

...is not the correct way to toggle a pin. This is...

#define TOGGLEd2     PIND = B00000100  // D2 Toggle
#define TOGGLEd2     PORTD ^= B00000100  // D2 Toggle

?

@Coding Badly Thank you, I will make the changes in the posted code.

Coding Badly is correct. You do not need to read from, OR, or XOR the pin.

Can you explain? I though PINX were read only, and why setting it to a value would toggle a bit? I don't understand.

It's called the Nick/Coding Badly shuffle ;) the data sheet says if you write a bit pattern to the PINX port it will toggle that pin.

Weird but cool :P

Coding Badly or Nick

I tried PINB = B00100000; And PINB |= B00100000; //two less bytes than PINB = B00100000

They both work but for some reason the second uses 2 bytes less code. i.e PINB |= B00100000; uses two less bytes less than PINB = B00100000; Suggestions why this may be?

The compiler reduces the second expression to a single SBI (set bit) instruction. The first requires a LDI (load immediate) followed by an OUT (port output).

@CB Thankyou

Summary
// ~70ns pulse using 4 bytes FASTEST
PINB = 0b00100000;
PINB = 0b00100000;

// ~130ns pulse using 2 bytes
PINB |= _BV(PINB5);
PINB |= _BV(PINB5);

// ~200ns pulse using 8 bytes
PORTB ^= B00100000;
PORTB ^= B00100000;

You are welcome.