CT
Login
IOT & Robotics
September 5, 2026 8 min read

Arduino Functions

Hs
Hemant singh
Technical Writer & Educator

Arduino provides many built-in functions that make it easy to control hardware and read information from sensors.

These functions allow the Arduino to:

  1. Configure pins
  2. Turn devices ON or OFF
  3. Read digital signals
  4. Read analog signals
  5. Generate PWM output
  6. Create delays
  7. Perform tasks based on time without blocking the program

In this lesson, we will learn:

  1. pinMode()
  2. digitalWrite()
  3. digitalRead()
  4. analogRead()
  5. analogWrite()
  6. delay()
  7. millis()

1. pinMode()

The pinMode() function is used to configure an Arduino pin as an input or output.

Syntax


pinMode(pin, mode);

Here:

pin → The Arduino pin number.

mode → Defines how the pin will be used.

Common modes are:

  1. INPUT
  2. OUTPUT
  3. INPUT_PULLUP

Example


pinMode(13, OUTPUT);

This configures digital pin 13 as an output.

We can now use pin 13 to control something such as an LED.

Input Example


pinMode(2, INPUT);

This configures pin 2 as an input.

We can use it to read a push button or another digital signal.

INPUT_PULLUP

Arduino also provides an internal pull-up resistor.


pinMode(2, INPUT_PULLUP);

This allows us to connect a push button without necessarily adding an external pull-up resistor.

With INPUT_PULLUP, the input is normally read as HIGH and becomes LOW when the button is connected to GND and pressed.

Example


int buttonPin = 2;

void setup() {
pinMode(buttonPin, INPUT_PULLUP);
}

void loop() {
int state = digitalRead(buttonPin);

if (state == LOW) {
Serial.println("Button Pressed");
}
}

2. digitalWrite()

The digitalWrite() function is used to set a digital output pin to either:

  1. HIGH
  2. LOW

Syntax


digitalWrite(pin, value);

Example


digitalWrite(13, HIGH);

This sets pin 13 to a HIGH output state.

To set it LOW:


digitalWrite(13, LOW);

Turning an LED ON and OFF

For a typical LED connected appropriately to a digital output:


int ledPin = 13;

void setup() {
pinMode(ledPin, OUTPUT);
}

void loop() {
digitalWrite(ledPin, HIGH);
delay(1000);

digitalWrite(ledPin, LOW);
delay(1000);
}

The LED will turn ON for one second and OFF for one second.

Understanding HIGH and LOW

For a typical Arduino Uno digital output:

HIGH → approximately 5V

LOW → approximately 0V

The exact electrical behavior should always be understood from the board's specifications.

3. digitalRead()

The digitalRead() function is used to read the state of a digital input pin.

A digital input generally has two logical states:

  1. HIGH
  2. LOW

Syntax


digitalRead(pin);

The function returns either HIGH or LOW.

Example


int buttonPin = 2;

void setup() {
pinMode(buttonPin, INPUT_PULLUP);
Serial.begin(9600);
}

void loop() {
int buttonState = digitalRead(buttonPin);

Serial.println(buttonState);

delay(500);
}

When the button is not pressed, the pin will normally read:

HIGH

When the button is pressed and connected to GND:

LOW

Example with LED

We can use a push button to control an LED.


int buttonPin = 2;
int ledPin = 13;

void setup() {
pinMode(buttonPin, INPUT_PULLUP);
pinMode(ledPin, OUTPUT);
}

void loop() {
int buttonState = digitalRead(buttonPin);

if (buttonState == LOW) {
digitalWrite(ledPin, HIGH);
}
else {
digitalWrite(ledPin, LOW);
}
}

Now:

Button pressed → LED ON

Button released → LED OFF

4. analogRead()

The analogRead() function is used to read an analog voltage from an analog input.

This is extremely important for sensors such as:

  1. Soil moisture sensors
  2. Potentiometers
  3. Light sensors
  4. Temperature sensors with analog output

Syntax


analogRead(pin);

On the Arduino Uno, the analog inputs are typically:

A0 to A5

Arduino Uno ADC

The Arduino Uno has a 10-bit ADC.

This means an analog reading is represented using values from:

0 to 1023

So:

0 → Lowest input level

1023 → Highest input level

For an Uno's default analog reference, the full-scale range corresponds approximately to 0V to the board's analog reference voltage, commonly 5V.

Example


int sensorPin = A0;

void setup() {
Serial.begin(9600);
}

void loop() {
int value = analogRead(sensorPin);

Serial.println(value);

delay(1000);
}

The Serial Monitor might show:

512
510
515
508

The actual values depend on the voltage coming from the connected sensor.

Example with Potentiometer

Connect a potentiometer so that:

One outer pin → 5V

Other outer pin → GND

Middle pin → A0

Then:


int potPin = A0;

void setup() {
Serial.begin(9600);
}

void loop() {
int value = analogRead(potPin);

Serial.println(value);

delay(500);
}

When you rotate the potentiometer, the voltage at A0 changes and the analog reading changes.

5. analogWrite()

The analogWrite() function is commonly used to control the PWM duty cycle on supported Arduino pins.

Despite its name, on the Arduino Uno it does not generate a continuously varying analog voltage. It generates a PWM signal.

PWM

PWM stands for Pulse Width Modulation.

PWM rapidly switches a digital output between HIGH and LOW.

By changing the percentage of time the signal stays HIGH, we can control the average power delivered to some loads.

Syntax


analogWrite(pin, value);

On the Arduino Uno, the value is normally:

0 to 255

Where:

0 → 0% duty cycle

255 → 100% duty cycle

Values between them produce intermediate duty cycles.

Example


int ledPin = 9;

void setup() {
pinMode(ledPin, OUTPUT);
}

void loop() {
analogWrite(ledPin, 128);
}

A value of 128 produces approximately a 50% PWM duty cycle.

For an LED, this can make the LED appear partially bright.

Example: LED Brightness


int ledPin = 9;

void setup() {
pinMode(ledPin, OUTPUT);
}

void loop() {

for (int brightness = 0; brightness <= 255; brightness++) {
analogWrite(ledPin, brightness);
delay(10);
}

for (int brightness = 255; brightness >= 0; brightness--) {
analogWrite(ledPin, brightness);
delay(10);
}
}

The LED gradually becomes brighter and then gradually becomes dimmer.

PWM Pins on Arduino Uno

On the standard Arduino Uno, the commonly marked PWM pins are:

3, 5, 6, 9, 10, 11

These pins are marked with a ~ symbol on many Uno boards.

Only supported PWM pins should be used with analogWrite() when PWM output is required.

6. delay()

The delay() function pauses the program for a specified amount of time.

Syntax


delay(milliseconds);

The value is given in milliseconds.

Common Values

1000 milliseconds = 1 second

500 milliseconds = 0.5 second

100 milliseconds = 0.1 second

Example


delay(1000);

This pauses the program for approximately one second.

LED Example


int ledPin = 13;

void setup() {
pinMode(ledPin, OUTPUT);
}

void loop() {

digitalWrite(ledPin, HIGH);
delay(1000);

digitalWrite(ledPin, LOW);
delay(1000);
}

The LED turns ON for one second and OFF for one second.

Problem with delay()

delay() is easy to understand, but it blocks the program.

For example:


delay(5000);

During those five seconds, the program cannot continue normal execution of the code after that statement.

This can become a problem when an IoT device needs to perform multiple tasks at the same time.

For example, an ESP32 may need to:

  1. Read a sensor
  2. Update a display
  3. Check a button
  4. Control a relay
  5. Communicate over Wi-Fi

Using long delay() calls can make the system less responsive.

7. millis()

The millis() function returns the number of milliseconds that have passed since the Arduino started running the current program.

Syntax


millis();

It returns an unsigned long value representing elapsed milliseconds.

Example


unsigned long currentTime = millis();

If approximately 5 seconds have passed since startup:

currentTime ≈ 5000

Why Use millis()?

millis() allows us to perform tasks based on time without blocking the entire program with a long delay().

For example, suppose we want to read a soil moisture sensor every second.

Instead of:


delay(1000);

we can check elapsed time.

Example


const int sensorPin = A0;

unsigned long previousTime = 0;

const unsigned long interval = 1000;

void setup() {
Serial.begin(9600);
}

void loop() {

unsigned long currentTime = millis();

if (currentTime - previousTime >= interval) {

previousTime = currentTime;

int value = analogRead(sensorPin);

Serial.println(value);
}
}

This reads the sensor approximately every 1000 milliseconds while allowing the rest of the loop() function to continue running.

delay() vs millis()

The difference is important for Arduino and IoT programming.

delay()

delay() pauses the program.

Example:


delay(1000);

The program waits for approximately one second before continuing.

millis()

millis() allows us to check how much time has passed without blocking the program.

This is much more useful when an IoT device needs to perform multiple tasks.

Practical Example: Multiple Tasks with millis()

Suppose our IoT system needs to:

  1. Read a soil moisture sensor every 1 second
  2. Blink an LED every 500 milliseconds
  3. Perform another task every 2 seconds

We can use millis() to manage these tasks independently.


const int sensorPin = A0;
const int ledPin = 13;

unsigned long sensorPreviousTime = 0;
unsigned long ledPreviousTime = 0;

const unsigned long sensorInterval = 1000;
const unsigned long ledInterval = 500;

void setup() {

pinMode(ledPin, OUTPUT);

Serial.begin(9600);
}

void loop() {

unsigned long currentTime = millis();

if (currentTime - sensorPreviousTime >= sensorInterval) {

sensorPreviousTime = currentTime;

int moisture = analogRead(sensorPin);

Serial.print("Moisture: ");
Serial.println(moisture);
}

if (currentTime - ledPreviousTime >= ledInterval) {

ledPreviousTime = currentTime;

digitalWrite(ledPin, !digitalRead(ledPin));
}
}

Here, the sensor reading and LED operation use separate timing intervals.

This is a very important technique for larger Arduino and IoT projects.

Summary of Arduino Functions

pinMode()

Used to configure a pin as input or output.

Example:


pinMode(13, OUTPUT);

digitalWrite()

Used to set a digital output HIGH or LOW.

Example:


digitalWrite(13, HIGH);

digitalRead()

Used to read a digital input.

Example:


int state = digitalRead(2);

analogRead()

Used to read an analog input.

Example:


int value = analogRead(A0);

analogWrite()

Used to output PWM on supported pins.

Example:


analogWrite(9, 128);

delay()

Pauses the program for a specified number of milliseconds.

Example:


delay(1000);

millis()

Returns the number of milliseconds elapsed since the program started.

Example:


unsigned long time = millis();

What We Can Build Using These Functions

Once these functions are understood, we can already build many useful Arduino projects.

LED

pinMode() + digitalWrite() + delay()

Push Button

pinMode() + digitalRead() + digitalWrite()

Potentiometer

analogRead() + Serial.println()

LED Brightness Control

analogRead() + analogWrite()

Soil Moisture Monitor

analogRead() + if + Serial.println()

Automatic Plant Watering

analogRead() + if + digitalWrite() + relay/pump control

Advanced IoT Timing

millis() + sensors + communication + outputs

In this category