Have you ever wanted to dim an LED instead of just turning it ON and OFF? That’s one of the first exciting things beginners try with Arduino. And honestly, it feels much more like a “real electronics project” compared to a simple blinking LED.

Here’s the thing… controlling LED brightness using Arduino is actually very simple once you understand PWM (Pulse Width Modulation). You don’t need expensive components or advanced coding knowledge. Just an Arduino board, an LED, and a few lines of code are enough.

In this guide, you’ll learn:

What PWM is and how it works
How Arduino controls LED brightness
Circuit connections step by step
Complete Arduino PWM code
Common beginner mistakes
Practical tips for smoother brightness control

Let’s understand this step by step.

What is PWM in Arduino?
Components Required
Circuit Diagram and Connections
Arduino PWM LED Brightness Code
Understanding the Code
Common Beginner Mistakes
Real-World Uses of PWM
Conclusion
FAQs

What is PWM in Arduino?

PWM stands for Pulse Width Modulation. It’s a technique Arduino uses to simulate analog output using digital pins.

Now you might think:

“Wait… Arduino pins are either HIGH or LOW. So how can brightness change?”

Good question.

Arduino rapidly turns the LED ON and OFF thousands of times per second. If the LED stays ON longer than OFF, it appears brighter to our eyes. If it stays OFF longer, it looks dimmer.

This is called the duty cycle.

A higher duty cycle = brighter LED
A lower duty cycle = dimmer LED

Arduino uses values between 0 and 255 for PWM:

PWM Value	Brightness Level
0	LED OFF
64	Dim
128	Medium
255	Fully Bright

Most beginners make this mistake: they try using regular digital pins instead of PWM pins.

On most Arduino boards, PWM pins are marked with a ~ symbol.

For example on Arduino Uno:

These pins support PWM output.

Components Required

You only need a few basic components for this project.

Component	Quantity
Arduino Uno	1
LED	1
220Ω Resistor	1
Breadboard	1
Jumper Wires	2–3

The resistor is important because it protects the LED from excessive current.

In real projects, this matters a lot. Without a resistor, you can permanently damage the LED or even the Arduino pin.

Circuit Diagram and Connections

The wiring is extremely simple.

Follow these connections:

Connect the LED positive leg (long leg) to PWM pin 9
Connect the LED negative leg to the resistor
Connect the resistor to GND

Connection Summary

Arduino Pin	Connected To
Pin 9	LED Positive
GND	Resistor
Resistor	LED Negative

[Image: Arduino PWM LED circuit diagram]
Alt text: Arduino LED brightness control using PWM pin 9

[Image: Breadboard connection example]
Alt text: Arduino Uno LED dimming project setup

Arduino PWM LED Brightness Code

Now comes the fun part — coding.

Arduino makes PWM incredibly easy using the analogWrite() function.

Here’s the complete code:

// Arduino PWM LED Brightness Control

int ledPin = 9;   // PWM pin
int brightness = 0;
int fadeAmount = 5;

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

void loop() {

  analogWrite(ledPin, brightness);

  brightness = brightness + fadeAmount;

  // Reverse fading direction
  if (brightness <= 0 || brightness >= 255) {
    fadeAmount = -fadeAmount;
  }

  delay(30);
}

Understanding the Code

If you’re a beginner, don’t worry. The logic is easier than it looks.

`analogWrite()`

This function controls PWM output.

analogWrite(ledPin, brightness);

The brightness value can be between:

0 → completely OFF
255 → maximum brightness

So if you write:

analogWrite(ledPin, 128);

the LED will glow at about 50% brightness.

`fadeAmount`

This variable controls how quickly brightness changes.

int fadeAmount = 5;

A larger number makes fading faster.

A smaller number creates smoother transitions.

Brightness Reversal Logic

This part is very important:

if (brightness <= 0 || brightness >= 255) {
  fadeAmount = -fadeAmount;
}

When brightness reaches maximum or minimum level, Arduino reverses the fading direction.

That’s how the LED smoothly fades in and out continuously.

Uploading the Code to Arduino

Once your wiring is complete:

Open Arduino IDE
Connect Arduino using USB cable
Select the correct board
Choose the correct COM port
Click Upload

After uploading, the LED should slowly fade brighter and dimmer.

If nothing happens, double-check:

PWM pin selection
LED polarity
USB connection
COM port

Most beginners accidentally connect the LED backward. The long leg should face the Arduino output pin.

Why PWM is So Useful

PWM is used almost everywhere in electronics.

Here are some common applications:

LED brightness control
Motor speed control
Fan speed adjustment
Audio signal generation
RGB LED color mixing

Once you understand PWM, you unlock a huge number of Arduino projects.

In real projects, PWM helps save power and gives more precise control over devices.

Advanced Tip: Control Brightness with a Potentiometer

After trying the basic project, you can upgrade it using a potentiometer.

This allows you to manually adjust brightness by rotating a knob.

The idea is simple:

Arduino reads analog input from potentiometer
Converts it into PWM output
LED brightness changes instantly

This is commonly used in:

Light dimmers
Volume controls
Adjustable lamps

[Image: Arduino potentiometer LED dimming project]
Alt text: Arduino LED dimmer using potentiometer and PWM

Common Beginner Mistakes

Here are a few issues many beginners face:

Using Non-PWM Pins

analogWrite() only works properly on PWM-supported pins.

Always check for the ~ symbol.

Forgetting the Resistor

Directly connecting LEDs without a resistor can burn them out.

A 220Ω resistor is usually perfect for beginner projects.

Wrong LED Direction

LEDs are polarized.

Long leg = positive
Short leg = negative

If reversed, the LED won’t glow.

Using Very Large Delay Values

If delay is too high:

delay(1000);

the fading effect becomes rough and slow.

Smaller values create smoother animation.

PWM vs Analog Output

Many beginners confuse PWM with true analog output.

Here’s the difference:

PWM Output	True Analog Output
Rapid ON/OFF pulses	Continuous voltage
Simulated analog	Real analog signal
Available on Arduino Uno	Rare on basic boards

Arduino Uno does not generate real analog voltage. It simulates it using PWM.

But for LEDs and motors, PWM works perfectly.

Suggested External Resources

Conclusion

Learning how to control LED brightness using Arduino is one of the best beginner-friendly projects because it teaches both coding and electronics together.

You learned how PWM works, how to connect the circuit, and how the analogWrite() function changes LED brightness smoothly. Once you get comfortable with PWM, you can start building more advanced projects like RGB lighting systems, motor controllers, and smart home devices.

Don’t worry if your setup doesn’t work perfectly the first time. Almost every beginner connects the LED backward at least once. That’s part of learning electronics.

Try changing the brightness speed, experiment with different PWM values, and build your own variations. That’s where the real fun starts.

FAQs

Can I use any Arduino pin for PWM?

No. Only PWM-supported pins can use analogWrite(). On Arduino Uno, these are usually pins 3, 5, 6, 9, 10, and 11.

Why is my LED not dimming properly?

This usually happens because:

You used a non-PWM pin
The LED is connected backward
The resistor value is incorrect

What does `analogWrite()` do?

It generates PWM signals that simulate analog output by rapidly switching the pin ON and OFF.

Can PWM control motor speed too?

Yes. PWM is commonly used to control DC motor speed and fan speed.

How to Control LED Brightness Using Arduino (PWM Guide)

Table of Contents