NOTE: Digital pin 13 is harder to use as a digital input than the other digital pins because it has an LED and resistor attached to it that's soldered to the board on most boards. If you enable its internal 20k pull-up resistor, it will hang at around 1.7 V instead of the expected 5V because the onboard LED and series resistor pull the voltage level down, meaning it always returns LOW. If you must use pin 13 as a digital input, use an external pull down resistor.

• digitalRead()

NOTE: Digital pin 13 is harder to use as a digital input because has an LED and resistor attached to it that's soldered to the board on most boards. If you enable its internal 20k pull-up resistor, it will hang at around 1.7 V instead of the expected 5V because the onboard LED and series resistor pull the voltage level down, meaning it always returns LOW. If you must use pin 13 as a digital input, use an external pull down resistor.

NOTE: Digital pin 13 has an LED and resistor attached to it that's soldered to the board on most boards, so it's not advised to use it as a digital input. If you enable its internal 20k pull-up resistor, it will hang at around 1.7 V instead of the expected 5V because the onboard LED and series resistor pull the voltage level down, meaning it always returns LOW.

Properties of Pins Configured as INPUT

Arduino (Atmega) pins default to inputs, so they don't need to be explicitly declared as inputs with pinMode(). Pins configured as inputs are said to be in a high-impedance state. One way of explaining this is that input pins make extremely small demands on the circuit that they are sampling, say equivalent to a series resistor of 100 megohm in front of the pin. This means that it takes very little current to move the input pin from one state to another, and can make the pins useful for such tasks as implementing a capacitive touch sensor, reading an LED as a photodiode, or reading an analog sensor with a scheme such as RCTime.

This also means however, that input pins with nothing connected to them, or with wires connected to them that are not connected to other circuits, will report seemingly random changes in pin state, picking up electrical noise from the environment, or capacitively coupling the state of a nearby pin.

Pullup Resistors

Often it is useful to steer an input pin to a known state if no input is present. This can be done by adding a pullup resistor (to +5V), or a pulldown resistor (resistor to ground) on the input, with 10K being a common value.

There are also convenient 20K pullup resistors built into the Atmega chip that can be accessed from software. These built-in pullup resistors are accessed in the following manner.

pinMode(pin, INPUT); // set pin to input digitalWrite(pin, HIGH); // turn on pullup resistors

digitalWrite() sets PORT register LOW (PULLUPS OFF) == 0 LOW == 0

digitalRead() reads the PIN register returns 0 returns 1

                                           INPUT STATE (DDRx == 0)    |    OUTPUT STATE (DDRx == 1)

                        Voltage at Pin              Voltage < 2.5     |    Voltage > 2.5

                       Voltage at Pin        Voltage < 2.5     |    Voltage > 2.5

                                      INPUT STATE (DDRx == 0)    |    OUTPUT STATE (DDRx == 1)

                                         INPUT STATE (DDRx == 0)    |    OUTPUT STATE (DDRx == 1)

                                INPUT STATE (DDRx == 0)    |      OUTPUT STATE (DDRx == 1)

digitalWrite() sets PORT register LOW (PULLUPS OFF) == 0 LOW == 0

                                           HIGH (PULLUPS ON) ==  1         HIGH == 1

                                     INPUT STATE (DDRx == 0)    |      OUTPUT STATE (DDRx == 1)

   I/O condition          pin state         register states 

                                            DDRx  == 0
                         PULLUPS ON         PORTx == 1

                                            DDRx  == 0
                        PULLUPS OFF         PORTx == 0

                                            DDRx  == 1
                           PIN HIGH         PORTx == 1

                                            DDRx  == 1
                            PIN LOW         PORTx == 0

Register Settings Chart

Arduino function low level result pin condition

pinMode() sets the DDR register INPUT == 0

digitalWrite() sets PORT register LOW (PULLUPS OFF) == 0 LOW == 0

                                           HIGH (PULLUPS ON) ==  1             HIGH == 1

                         Voltage at Pin        Voltage < 2.5      |      Voltage > 2.5

digitalRead() reads the PIN register returns 0 returns 1

                                  INPUT STATE (DDRx == 0)       |       OUTPUT STATE (DDRx == 1)

                                                   OUTPUT == 1

                                             INPUT STATE (DDRx == 0)       |       OUTPUT STATE (DDRx == 1)

                                       HIGH (PULLUPS ON) ==  1             HIGH == 1

The PIN register is a read-only register that indicates the electrical condition of the pin. In other words, if the voltage level of the pin is above about 2.5 volts (or half the supply voltage if VCC is less than 5 volts) this register will read as a 1, if not it will read as a 0. The PIN register cannot be written, since its value depends on the external voltage level of the pin.

pinMode() sets the DDR register INPUT == 0

digitalWrite() sets PORT register LOW (PULLUPS OFF) == 0 LOW == 0

   I/O condition          pin state       register states 

                                        DDRx  == 0
                         PULLUPS ON     PORTx == 1

                                        DDRx  == 0
                        PULLUPS OFF     PORTx == 0

                                         DDRx  == 1
                           PIN HIGH      PORTx == 1

                                         DDRx  == 1
                            PIN LOW      PORTx == 0

Arduino function low level result pin condition

Arduino function low level result pin condition

   I/O condition      pin state     register states 

The PIN register is a read only register that indicates the electrical condition of the pin. In other words, if the voltage level of the pin is above about 2.5 volts (or half the supply voltage if VCC is less than 5 volts) this register will read as a 1, if not it will read as a 0. The PIN register cannot be written, since its value depends on the external voltage level of the pin.

The PIN register is a read only register that indicates the electrical condition of the pin. In other words, if the voltage level of the pin is above about 2.5 volts this register will read as a 1, if not it will read as a 0. The PIN register cannot be written, since its value depends on the external voltage level of the pin.

The setting of the PORT register controls whether the pin is HIGH or LOW, when the pin is in an OUTPUT state (DDR register set). When the pin is configured to an INPUT state (DDR register reset), the PORT register controls whether the pin has its pullup resistor set. PORT registers may be either read or written.

The setting of the DDR register controls whether the pin is an an input or output. DDR registers may be either read or written.

As you can see then, the DDR and PORT registers interact in controlling the pin states, so understanding the state of the pin requires understanding both registers.

pinMode() sets the DDR register INPUT == 0

                                               OUTPUT == 1

                                             INPUT STATE       |       OUTPUT STATE

                      Voltage at Pin        Voltage < 2.5      |      Voltage > 2.5

digitalRead() reads the PIN register returns 0 returns 1

digitalRead() reads the PIN register returns 0 returns 1

digitalWrite() sets PORT register LOW (PULLUPS OFF) == 0 LOW == 0

                                     HIGH (PULLUPS ON) ==  1             HIGH == 1

                      Voltage at Pin        Voltage < 2.5       |          Voltage > 2.5

                      Voltage at Pin        Voltage <           |          Voltage > 2.5

                      Voltage at Pin    Voltage < 2.5           |          Voltage > 2.5

digitalRead() reads the PIN register returns 0 returns 1

                      Voltage at Pin    Voltage < 2.5          |          Voltage > 2.5

                                             INPUT STATE        |      OUTPUT STATE

                  Voltage at Pin           Voltage < 2.5          |   Voltage > 2.5

                                         INPUT STATE        |      OUTPUT STATE

            Voltage at Pin           Voltage < 2.5          |   Voltage > 2.5

digitalWrite() sets PORT register LOW (PULLUPS OFF) == 0 LOW == 0

                                     HIGH (PULLUPS ON) ==  1         HIGH == 1

digitalWrite() sets PORT register PULLUPS OFF == 0 LOW == 0

                                     PULLUPS ON == 1          HIGH == 1

                                     INPUT STATE        |     OUTPUT STATE

            Voltage at Pin           Voltage < 2.5      |   Voltage > 2.5

digitalRead() reads the PIN register returns 0 returns 1

            Voltage at Pin           Voltage < 2.5    |   Voltage > 2.5

• pinMode()
• digitalWrite()
• digitalRead()

back to Foundations

See Also

• Port Manipulation
• pinMode()?
• digitalWrite()?
• digitalRead()?

Often it is useful to steer an input pin to a known state if no input is present. This can be done by adding a pullup resistor (to +5V), or a pulldown resistor (resistor to ground) on the input, with 10K being a common value.

Register Settings Diagram

digitalRead() reads the PIN register returns 0 returns 1

                                     PULLUPS ON == 1        HIGH == 1

@]

Voltage at Pin Voltage < 2.5 | Voltage > 2.5

digitalRead() reads the PIN register reports 0 reports 1

                                     Voltage < 2.5   |   Voltage > 2.5

digitalRead() READS the PIN register

                                     PULLUPS ON == 1        HIGH == 1@]

                      PULLUPS ON     PORTx == 1

                                     DDRx  == 0
                     PULLUPS ON      PORTx == 1

                                     DDRx  == 0
                     PULLUPS OFF     PORTx == 0

                                     DDRx  == 1
                       PIN HIGH      PORTx == 1

                                     DDRx  == 1
                        PIN LOW      PORTx == 0

pinMode() sets the DDR register INPUT == 0

                                     OUTPUT == 1

                                     INPUT STATE      |    OUTPUT STATE

digitalWrite() sets PORT register PULLUPS OFF == 0 LOW == 0

                                     PULLUPS ON == 1        HIGH == 1

digitalWrite() sets PORT register PULLUPS OFF == 0 LOW == 0

                                   PULLUPS ON == 1        HIGH == 1

pinMode() sets the DDR register INPUT == 0

                                   OUTPUT == 1

digitalWrite() sets PORT register PULLUPS ON == 1 HIGH == 1

                                   PULLUPS OFF == 0       LOW == 0

                                   INPUT STATE      |    OUTPUT STATE

digitalWrite() sets PORT register PULLUPS ON == 1 HIGH == 1 /

                                   PULLUPS OFF == 0    LOW == 0 / 

                                   INPUT STATE     | OUTPUT STATE

digitalWrite() sets PORT register PULLUPS ON == 1 HIGH == 1 /

                                   PULLUPS OFF == 0 LOW == 0 / 

                                   DDRx  == 0
                   PULLUPS ON      PORTx == 1

PIN SET AS INPUT

                                   DDRx  == 0
                   PULLUPS OFF     PORTx == 0

digitalWrite() sets PORT register HIGH == 1 / PULLUPS ON == 1

                                   LOW == 0 / PULLUPS OFF == 0

Properties of Pins Configured as INPUT

Properties of Pins Configured as OUTPUT

pinMode() sets the DDR register OUTPUT == 1

                                   INPUT  == 0

digitalWrite sets PORT register HIGH == 1 / PULLUPS ON = 1

                                   LOW == 0 / PULLUPS OFF

Register Settings Block Diagram

                                   DDRx  == 1
                     PIN HIGH      PORTx == 1

PIN SET AS OUTPUT

                                   DDRx  == 1
                      PIN LOW      PORTx == 0

                                   DDRx  == 0
                   PULLUPS ON      PORTx == 1

PIN SET AS INPUT

                                   DDRx  == 0
                   PULLUPS OFF     PORTx == 0

Pins Configured as INPUT

Arduino (Atmega) pins default to inputs, so they don't need to be explicitly declared as inputs with pinMode(). Pins configured as inputs are said to be in a high-impedance state. One way of explaining this is that input pins make extremely small demands on the circuit that they are sampling, say equivalent to a series resistor of 100 megohm in front of the pin. This means that it takes very little current to move the input pin from one state to another, and can make the pins useful for such tasks as implementing a capacitive touch sensor, reading an LED as a photodiode, or reading an analog sensor with a scheme such as RCTime.

This also means however, that input pins with nothing connected to them, or with wires connected to them that are not connected to other circuits, will report seemingly random changes in pin state, picking up electrical noise from the environment, or capacitively coupling the state of a nearby pin.

Pullup Resistors

Often it is useful to steer an input pin to a known state if no input is present. This can be done by adding a pullup resistor (to +5V), or pulldown resistor (resistor to ground) on the input, with 10K being a common value.

There are also convenient 20K pullup resistors built into the Atmega chip that can be accessed from software. These built-in pullup resistors are accessed in the following manner.

pinMode(pin, INPUT);           // set pin to input
digitalWrite(pin, HIGH);       // turn on pullup resistors

The setting of the DDR register controls whether the pins is an an input or output. DDR registers may be either read or written.

The setting of the PORT register controls whether the pin is HIGH or LOW, when the pin is in an OUTPUT state. When the pin is configured to an INPUT state, the PORT register controls whether the pin has its pullup resistor set. PORT registers may be either read or written.

The PIN register is a read only register that indicates the electrical condition of the pin. In other words, if the voltage level of the pin is above about 2.5 volts this register will read as a 1, if not it will read as a 0.

There are three port registers that control every pin on the Atmega168/328 chip. The lower case x's in the names are place holders for individual port letter designations. This will be more clear if you glance at the Port Manipulation page.

The best way to really understand the nature of Atmega microcontroller pins used by the Arduino, is to understand the underlying port registers in the Atmega chip. These are the memory locations that control the electrical function of the pins. More details on this may be found in the Port Manipulation reference page.

There are three port registers that control every pin on the Atmega168/328 chip. The lower case x's in the names indicate that these names are common for each port on the chip. This will be more clear if you glance at the Port Manipulation page.

Port Registers That Control Atmega (Arduino) Pins

    DDRx - The Port Data Direction Register - read/write
    PORTx - The Port Data Register - read/write
    PINx - The Port Input Pins Register - read only 

The DDR registers control whether the pins is an an input or output. They may be either read or written.

The best way to really understand the nature of Atmega microcontroller pins used by the Arduino, is to to visualize the underlying port registers in the Atmega chip. These are the memory locations that control the electrical function of the pins. More details on this may be found in the Port Manipulation reference page.

The best way to really understand the nature of microcontroller pins is to to visualize the underlying port registers in the Atmega chip. These are the memory locations that control the electrical function of the pins. More details on this may be found in the Port Manipulation reference page.

The best way to really understand the nature of microcontroller pins is to to visualize the underlying port registers in the Atmega chip. These are the memory locations that control the electrical function of the pins. More details on this may be found in the PortManipulation reference page.

The best way to really understand the nature of microcontroller pins is to to visualize the underlying port registers in the Atmega chip. These are the memory locations that control the electrical function of the pins. More details on this may be found in the Reference/PortManipulation? reference page.

Understanding PORT registers

The best way to really understand the nature of microcontroller pins is to to visualize the underlying port registers in the Atmega chip. These are the memory locations that control the electrical function of the pins. More details on this may be found in the PortManipulation? reference page.

Arduino (Atmega) pins default to inputs, so they don't need to be explicitly declared as inputs with pinMode(). Pins configured as inputs are said to be in a high-impedance state. One way of explaining this is that input pins make extremely small demands on the circuit that they are sampling, say equivalent to a series resistor of 100 megohm in front of the pin. This means that it takes very little current to move the input pin from one state to another, and can make the pins useful for such tasks as implementing a capacitive touch sensor, reading an LED as a photodiode, or reading an analog sensor with a scheme such as RCTime.

Arduino (Atmega) pins default to inputs, so they don't need to be explicitly declared as inputs with pinMode(). Pins configured as inputs are said to be in a high-impedance state. One way of explaining this is that input pins make extremely small demands on the circuit that they are sampling, say equivalent to a series resistor of 100 megohm in front of the pin. This means that it takes very little current to move the input pin from one state to another, and can make the pins useful for such tasks as implementing a capacitive touch sensor, reading an LED as a photodiode, or reading an analog sensor with a scheme such as RCTime.

This also means however, that input pins with nothing connected to them, or with wires connected to them that are not connected to other circuits, will report seemingly random changes in pin state, picking up electrical noise from the environment, or capacitively coupling the state of a nearby pin.

Arduino (Atmega) pins default to inputs, so they don't need to be explicitly declared as inputs with pinMode(). Pins configured as inputs are said to be in a high-impedance state. One way of explaining this is that input pins make extremely small demands on the circuit that they are sampling, say equivalent to a series resistor of 100 megohm in front of the pin. This means that it takes very little current to move the input pin from one state to another, and can make the pins useful for such tasks as implementing a capacitive touch sensor, reading a phototransistor, or reading an analog sensor with a scheme such as RCTime.

Arduino (Atmega) pins default to inputs, so they don't need to be explicitly declared as inputs with pinMode(). Pins configured as inputs are said to be in a high-impedance state. One way of explaining this is that input pins make extremely small demands on the circuit that they are sampling, say equivalent to a series resistor of 100 megohm in front of the pin. This means that it takes very little current to move the input pin from one state to another, and can make the pins useful for such tasks as implementing a capacitive touch sensor, reading a phototransistor, or reading an analog sensor with a scheme such as RCTime.

The pins on the Arduino can be configured as either inputs or outputs. This document explains the functioning of the pins in those modes. While the title of this document refers to digital pins, it is important to note that vast majority of Arduino (Atmega) analog pins, may be configured, and used, in exactly the same manner as digital pins.

Arduino (Atmega) pins default to inputs, so they don't need to be explicitly declared as inputs with pinMode(). Pins configured as inputs are said to be in a high-impedance state. One way of explaining this is that input pins make extremely small demands on the circuit that they are sampling, say equivalent to a series resistor of 100 megohm in front of the pin. This means that it takes very little current to move the input pin from one state to another, and can make the pins useful for such tasks as implementing a capacitive touch sensor.

Digital Pins

The digital pins on the Arduino can be configured as either inputs or outputs. This document explains the functioning of the pins in those modes.

Pins Configured as INPUT

Arduino (Atmega) pins default to inputs, so they don't need to be explicitly declared as inputs with pinMode(). Pins configured as inputs are said to be in a high-impedance state. One way of explaining this is that input pins make extremely small demands on the circuit that they are sampling, say equivalent to a series resistor of 100 Mega-ohms in front of the pin. This means that it takes very little current to move the input pin from one state to another, and can make the pins useful for such tasks as implementing a capacitive touch sensor.

Often it is useful to steer an input pin to a known state if no input is present. This can be done by adding a pullup resistor (to +5V), or pulldown resistor (resistor to ground) on the input, with 10K being a common value.

Pins Configured as OUTPUT

This also means however that input pins with nothing connected to them, or with wires connected to them that are not connected to other circuits, will report seemingly random changes in pin state, picking up electrical noise from the environment, or capacitively coupling the state of a nearby pin.

Often it is useful to steer an input pin to a known state if no input is present. This can be done by adding a pullup resistor(to +5V), or pulldown resistor (resistor to ground) on the input, with 10K being a common value.

Note also that the pullup resistors are controlled by the same registers (internal chip memory locations) that control whether a pin is HIGH or LOW. Consequently a pin that is configured to have pullup resistors turned on when the pin is an INPUT, will have the pin configured as HIGH if the pin is then swtiched to an OUTPUT with pinMode(). This works in the other direction as well, and an output pin that is left in a HIGH state will have the pullup resistors set if switched to an input with pinMode().

This also means however that input pins with nothing connected to them, or with wires connected to them that are not connected to other circuits, will report seemingly random changes in pin state, picking up electrical noise from the environment, or capacitively coupling the state of a nearby pin for example.

Often it is useful, to steer an input pin to a known state if no input is present. This can be done by adding a pullup (resistor to VCC), or pulldown resistor (resistor to ground) on the input, with 10K being a common value.

Note that the pullup resistors provide enough current to dimly light an LED connected to a pin that has been configured as an input. If LED's in a project seem to be working, but very dimly, this is likely what is going on, and the programmer has forgotten to use pinMode() to set the pins to outputs.

Note also that the pullup resistors are controlled by the same registers (internal chip memory locations) that control whether a pin is high or low. Consequently a pin that is configured to have pullup resistors turned on when the pin is an INPUT, will have the pin configured as HIGH if the pin is then swtiched to an OUTPUT with pinMode(). This works in the other direction as well, and an output pin that is left in a high state will have the pullup resistors set if switched to an input with pinMode().

Pullup Resistors

Note that the pullup resistors provide enough current to dimly light an LED connected to a pin that has been configured as an input. If LED's in a project seem to be working, but very dimly, this is likely what is going on, and you have forgotten to use pinMode to change the pins to outputs.

Note also that the pullup resistors are controlled by the same registers (internal chip memory locations) that control whether a pin is high or low. Consequently a pin that is configured to have pullup resistors turned on when the pin is an INPUT, will have the pin configured as HIGH if the pin is then swtiched to an OUTPUT. This works in the other direction as well and an output pin that is left in a high state will have the pullup resistors set if switched to an input with pinMode().

Foundations

Short circuits on Arduino pins, or attempting to run high current devices from them, can damage or destroy the output transistors in the pin, or damage the entire Atmega chip. Often this will result in a "dead" pin in the microcontroller but the remaining chip will still function adequately. For this reason it is a good idea to connect OUTPUT pins to other devices with 470Ω or 1k resistors, unless maximum current draw from the pins is required for a particular application.

Short circuits on Arduino pins, or attempting to run high current devices from them, can damage or destroy the output transistors in the pin, or damage the entire Atmega chip. Often this will result in a "dead" pin in the microcontroller but the remaining chip will still function adequately. For this reason it is a good idea to connect OUTPUT pins to other devices with 100Ω to 1k resistors.

Pins

Pins Configured as INPUT

Arduino (Atmega) pins default to inputs, so they don't need to be explicitly declared as inputs with pinMode(). Pins configured as inputs are said to be in a high-impedance state. One way of explaining this is that input pins make extremely small demands on the circuit that they are sampling, say equivalent to a series resistor of 100 Megohms in front of the pin. This means that it takes very little current to move the input pin from one state to another, and can make the pins useful for such tasks as implementing a capacitive touch sensor.

Often it is useful however, to steer an input pin to a known state if no input is present. This can be done by adding a pullup (resistor to VCC), or pulldown resistor (resistor to ground) on the input, with 10K being a common value.

There are also convenient 20K pullup resistors built into the Atmega chip that can be accessed from software. These built-in pullup resistors are accessed in the following manner.

pinMode(pin, INPUT);           // set pin to input
digitalWrite(pin, HIGH);       // turn on pullup resistors

Note that the pullup resistors provide enough current to dimmly light an LED connected to a pin that has been configured as an input. If LED's in a project seem to be working, but very dimmly, this is likely what is going on, and you have forgotten to use pinMode to change the pins to outputs.

Pins Configured as OUTPUT

Pins configured as OUTPUT with pinMode() are said to be in a low-impedance state. This means that they can provide a substantial amount of current to other circuits. Atmega pins can source (provide positive current) or sink (provide negative current) up to 40 mA (milliamps) of current to other devices/circuits. This is enough current to brightly light up an LED (don't forget the series resistor), or run many sensors, for example, but not enough current to run most relays, solenoids, or motors.

Short circuits on Arduino pins, or attempting to run high current devices from them, can damage or destroy the output transistors in the pin, or damage the entire Atmega chip. Often this will result in a "dead" pin in the microcontroller but the remaining chip will still function adequately. For this reason it is a good idea to connect OUTPUT pins to other devices with 470Ω or 1k resistors.