The Digital Input-Output Port

1Lab objectives

• Understanding the role of the DDRx, PORTx and PINx registers
• Configuring pins through direct register access, with bitwise operations
• Using the internal pull-up resistors to read buttons
• Implementing contact-bounce removal
• Comparing the speed of digitalWrite() with a direct register write

2Materials needed

• 1 Arduino Uno
• 1 Breadboard
• 4 LEDs
• 4 220 Ω resistors
• 2 Buttons
• 10 Jumper wires

3The three registers of a port

The ATmega328P has three ports: B (digital pins 8-13), C (analog pins A0-A5) and D (digital pins 0-7). Each is controlled by three 8-bit registers:

The complete configuration table

4Internal structure of a pin

5Register simulator

Click on bits to change the registers. The state of the pins at the bottom updates exactly per the configuration table - just like on the real microcontroller.

6Mask lab

You never modify the whole register if you want to change a single pin - that would affect the other seven. Bit masks are used, built with the shift operator:

Check below, bit by bit, what each operation does. Choose the & operator with operand B set to 11011111 to see how bit 5 gets cleared exactly.

7Wiring diagrams

8Contact bounce

A mechanical button does not switch cleanly. The metal contacts bounce for a few milliseconds on touch, generating dozens of false transitions. Without filtering, a single physical press is seen by the program as several presses.

9Debounce simulator

Follow, step by step, how the algorithm rejects false transitions and only accepts the stable state. Notice that the bounces at t = 102 and t = 107 produce no increment at all.

10Source code

Arduino functions vs. direct register access

void setup() {
  // --- Arduino variant: readable, but slow ---
  pinMode(13, OUTPUT);
  pinMode(2, INPUT_PULLUP);

  // --- equivalent register variant: fast ---
  DDRB  |= (1 << PB5);    // pin 13 = output
  DDRD  &= ~(1 << PD2);   // pin 2  = input
  PORTD |= (1 << PD2);    // enable pull-up on pin 2
}

void loop() {
  // reading the button: 0 = pressed, because of the pull-up
  if (!(PIND & (1 << PD2))) {
    PORTB |= (1 << PB5);    // turn on
  } else {
    PORTB &= ~(1 << PB5);   // turn off
  }
}

Measuring the speed difference

We do not have the serial monitor yet (lab 6), so we do not print the duration: we make it visible. Each method toggles the pin in a tight loop, and the pin drives a separate LED. The faster the method, the sooner the loop finishes and the shorter the "busy" LED stays lit. The difference is visible to the naked eye, and it can also be measured on an oscilloscope.

const uint16_t N = 20000;

void setup() {
  DDRB |= (1 << PB0);          // pin 8: the pin being toggled
  DDRB |= (1 << PB4);          // pin 12: marker "running digitalWrite"
  DDRB |= (1 << PB3);          // pin 11: marker "running the register variant"
}

void loop() {
  // ---- function-call variant: the marker on pin 12 stays lit as long as it runs
  PORTB |= (1 << PB4);
  for (uint16_t i = 0; i < N; i++) {
    digitalWrite(8, HIGH);
    digitalWrite(8, LOW);
  }
  PORTB &= ~(1 << PB4);

  delay(400);

  // ---- register variant: the marker on pin 11
  PORTB |= (1 << PB3);
  for (uint16_t i = 0; i < N; i++) {
    PORTB |=  (1 << PB0);
    PORTB &= ~(1 << PB0);
  }
  PORTB &= ~(1 << PB3);

  delay(400);
}

Complete debounce

const uint8_t BUTTON_PIN = 2;
const uint8_t LED_PIN   = 13;
const uint16_t DEBOUNCE_INTERVAL = 40;   // ms

bool ledState       = false;
bool lastReading    = HIGH;
bool stableState    = HIGH;
unsigned long lastChangeTime = 0;

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  bool reading = digitalRead(BUTTON_PIN);

  if (reading != lastReading) {          // any change restarts the timer
    lastChangeTime = millis();
    lastReading  = reading;
  }

  if (millis() - lastChangeTime > DEBOUNCE_INTERVAL) {
    if (reading != stableState) {        // the state has stabilized
      stableState = reading;

      if (stableState == LOW) {          // falling edge = a real press
        ledState = !ledState;
        digitalWrite(LED_PIN, ledState);   // a single toggle per press
      }
    }
  }
}

A light effect on four LEDs

void setup() {
  DDRB |= 0b00001111;    // pins 8, 9, 10, 11 as outputs, in a single operation
}

void loop() {
  // shift left
  for (uint8_t i = 0; i < 4; i++) {
    PORTB = (PORTB & 0xF0) | (1 << i);   // keep bits 4-7, set only one of bits 0-3
    delay(120);
  }
  // shift right, without repeating the ends
  for (int8_t i = 2; i > 0; i--) {
    PORTB = (PORTB & 0xF0) | (1 << i);
    delay(120);
  }
}

11Interactive circuit

An input pin is read from PINx, not from PORTx - and when you use the internal pull-up resistor, the logic is inverted: a pressed button means 0. The circuits below let you press the button with your mouse and watch the bit in PIND change in real time.

#include <avr/io.h>
#include <util/delay.h>

int main(void)
{
    DDRD  &= ~(1 << PD2);      // pin 2 is an INPUT
    PORTD |=  (1 << PD2);      // internal pull-up resistor, enabled
    DDRB  |=  (1 << PB5);      // pin 13 is an OUTPUT
    DDRD  |=  (1 << PD7);      // pin 7 is an OUTPUT

    while (1) {
        if (!(PIND & (1 << PD2))) {     // the bit is 0 -> button PRESSED
            PORTB |=  (1 << PB5);       // the "pressed" LED lights up
        } else {
            PORTB &= ~(1 << PB5);
        }

        /* The second LED copies the raw bit, with no negation.
           Watch them both: they are always in opposition. */
        if (PIND & (1 << PD2)) PORTD |=  (1 << PD7);
        else                   PORTD &= ~(1 << PD7);

        _delay_ms(150);
    }
}

#include <avr/io.h>
#include <util/delay.h>

int main(void)
{
    DDRD  &= ~(1 << PD2);      // pin 2 = INPUT (the button)
    PORTD |=  (1 << PD2);      // internal pull-up resistor
    DDRB  |=  (1 << PB5);      // pin 13 = OUTPUT (the LED)

    /* At idle the button gives 1. Pressed, it gives 0.
       If we only wrote "if it is 0, toggle the LED", the LED would toggle
       hundreds of times for as long as we hold the button. We want it to
       toggle ONCE, right at the moment of pressing - that is, exactly when
       the reading GOES from 1 to 0. To catch that transition, we remember
       what we read on the previous pass. */

    unsigned char previousState = 1;   // at idle the button gives 1

    while (1) {
        unsigned char currentState = (PIND & (1 << PD2)) ? 1 : 0;

        /* --- STEP 1 -------------------------------------------------
           Replace the 0 below with the condition for going from 1 to 0:
           "it was 1 before AND it is 0 now", written with == and &&.
           As long as you leave 0, the condition is always false and the
           LED does NOT light up - exactly what you see if you run the
           program now.                                                */

        if (0) {

            /* --- STEP 2 ---------------------------------------------
               Toggle bit PB5 of PORTB. The TOGGLE idiom is the one with
               ^= , from the previous lab. Write the line here: */



            /* --- STEP 3 ---------------------------------------------
               The button's contacts bounce for a few milliseconds. Put
               a 20 ms pause here to let them settle: */


        }

        /* --- STEP 4 ---------------------------------------------------
           The current reading becomes "the previous one" for the next
           pass. Without this line, the comparison has nothing to work
           with and the LED never lights up. Write it here:            */


        _delay_ms(5);
    }
}

12Work tasks

• Wire up 4 LEDs on pins 8-11 and light them sequentially, using only register operations.
• Connect a button on pin 2 with the internal pull-up; print its idle and pressed value over serial.
• Check what is read on an input pin left floating, with no pull-up.
• Implement software debounce and count presses; check that each physical press produces exactly one increment.
• Modify the program so each press reverses the direction of the light effect.
• Run the benchmark and note the ratio between digitalWrite() and direct access.
• Build a 4-bit binary counter on the LEDs, incremented on each button press.
• Try PORTB = 0b00000001; with no mask and observe what happens to the LED on D13.

13Extended application

14Review questions

15Resources

• This lab's handout (PDF)
• The complete lab handout
• The course page - all materials