LED brightness control in Raspberry Pi - Step-by-Step Execution

Concept Flow - LED brightness control

Start

↓

Setup GPIO pin for PWM

↓

Set initial brightness (duty cycle)

↓

Enter loop

↓

Increase brightness step

↓

Check if brightness > max

↓

Reset to min

↓

Apply brightness to LED

↓

Wait short delay

↓

Repeat loop

The program sets up a PWM pin on the Raspberry Pi to control LED brightness by changing the duty cycle in a loop, increasing brightness step by step and resetting after reaching max.

Execution Sample

Raspberry Pi

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)
pwm = GPIO.PWM(18, 1000)
pwm.start(0)

try:
    while True:
        for dc in range(0, 101, 10):
            pwm.ChangeDutyCycle(dc)
            time.sleep(0.2)
finally:
    pwm.stop()
    GPIO.cleanup()

This code smoothly increases LED brightness from off (0%) to full (100%) in steps of 10%, pausing briefly at each step.

Execution Table

Step	Duty Cycle (dc)	Action	LED Brightness	Delay (seconds)
1	0	Set PWM duty cycle to 0%	LED off	0.2
2	10	Increase duty cycle to 10%	Dim LED	0.2
3	20	Increase duty cycle to 20%	Slightly brighter	0.2
4	30	Increase duty cycle to 30%	Brighter	0.2
5	40	Increase duty cycle to 40%	More bright	0.2
6	50	Increase duty cycle to 50%	Half brightness	0.2
7	60	Increase duty cycle to 60%	More than half bright	0.2
8	70	Increase duty cycle to 70%	Bright LED	0.2
9	80	Increase duty cycle to 80%	Very bright	0.2
10	90	Increase duty cycle to 90%	Almost full brightness	0.2
11	100	Increase duty cycle to 100%	Full brightness	0.2
12	Loop repeats	Restart from 0%	LED off	0.2

💡 Loop runs indefinitely until program is stopped manually.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7	After Step 8	After Step 9	After Step 10	After Step 11	Final
dc (duty cycle)	0	0	10	20	30	40	50	60	70	80	90	100	0 (loop restart)

Key Moments - 3 Insights

Why does the LED brightness change smoothly instead of instantly?

Because the duty cycle changes in small steps (10% increments) with a short delay (0.2 seconds) between each step, as shown in execution_table rows 1-11.

What happens when the duty cycle reaches 100%?

The program resets the duty cycle back to 0% to start the brightness cycle again, as seen in execution_table row 12.

Why do we use PWM to control LED brightness?

PWM changes how long the LED is on versus off very quickly, which our eyes see as brightness changes. This is shown by changing the duty cycle variable 'dc' in the code and execution_table.

Visual Quiz - 3 Questions

Look at the execution_table at Step 5. What is the LED brightness when duty cycle is 40%?

A More bright

B LED off

C Dim LED

D Full brightness

💡 Hint

Check the 'LED Brightness' column at Step 5 in the execution_table.

At which step does the duty cycle reach full brightness (100%)?

A Step 10

B Step 11

C Step 12

D Step 9

💡 Hint

Look at the 'Duty Cycle (dc)' column in the execution_table to find 100%.

If the delay time is increased from 0.2 to 1 second, how would the execution_table change?

A The LED brightness would skip some levels.

B The duty cycle values would change to larger steps.

C The 'Delay (seconds)' column would show 1.0 instead of 0.2 for each step.

D The loop would stop after one cycle.

💡 Hint

Focus on the 'Delay (seconds)' column in the execution_table.

Concept Snapshot

LED brightness control uses PWM on a Raspberry Pi GPIO pin.
Set up PWM with frequency, then change duty cycle (0-100%) to adjust brightness.
Increase duty cycle in steps with delays for smooth brightness change.
Loop to repeat brightness cycle.
Use GPIO.cleanup() to reset pins after program ends.

Full Transcript

This example shows how to control LED brightness on a Raspberry Pi using PWM. First, the GPIO pin is set up for PWM output. The program starts PWM with 0% duty cycle, meaning LED is off. Then, inside a loop, the duty cycle increases from 0% to 100% in steps of 10%. Each step changes the LED brightness slightly brighter. After reaching 100%, the duty cycle resets to 0%, and the cycle repeats. A short delay after each step makes the brightness change smooth and visible. The variable 'dc' tracks the duty cycle value. The program runs indefinitely until stopped. Finally, PWM is stopped and GPIO pins are cleaned up to avoid issues. This method uses PWM to simulate different brightness levels by changing how long the LED is on in each cycle.

Practice

1. What does PWM stand for in the context of controlling LED brightness on a Raspberry Pi?

easy

A. Pulse Wire Mode

B. Power Wave Management

C. Pin Wiring Method

D. Pulse Width Modulation

Solution

1. Step 1: Understand PWM meaning

   PWM is a technique used to control power by switching it on and off quickly.

2. Step 2: Match PWM to full form

   Pulse Width Modulation means changing the width of the pulse to control power, which fits LED brightness control.

3. Final Answer:

   Pulse Width Modulation -> Option D

4. Quick Check:

   PWM = Pulse Width Modulation [OK]

Hint: PWM controls brightness by changing pulse width [OK]

Common Mistakes:

• Confusing PWM with power management
• Thinking PWM is a wiring method
• Mixing up acronyms

2. Which of the following is the correct way to start PWM on GPIO pin 18 with a frequency of 1000 Hz using RPi.GPIO?

easy

A. pwm = GPIO.PWM(18, 1000); pwm.start(0)

B. pwm = GPIO.PWM(18); pwm.start(1000)

C. pwm = GPIO.PWM(1000, 18); pwm.start(0)

D. pwm = GPIO.PWM(18, 0); pwm.start(1000)

Solution

1. Step 1: Check PWM constructor parameters

   RPi.GPIO PWM takes pin number first, then frequency in Hz.

2. Step 2: Verify start method usage

   start() takes initial duty cycle (0-100), so start(0) is correct for off initially.

3. Final Answer:

   pwm = GPIO.PWM(18, 1000); pwm.start(0) -> Option A

4. Quick Check:

   GPIO.PWM(pin, freq) then start(duty) [OK]

Hint: PWM(pin, frequency) then start(duty cycle) [OK]

Common Mistakes:

• Swapping frequency and pin
• Starting PWM with frequency instead of duty
• Using zero frequency

3. What will be the output brightness level of the LED after running this code snippet?

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)
pwm = GPIO.PWM(18, 500)
pwm.start(0)
pwm.ChangeDutyCycle(75)

medium

A. LED will be at 25% brightness

B. LED will be off

C. LED will be at 75% brightness

D. Code will cause an error

Solution

1. Step 1: Understand duty cycle effect

   Duty cycle 75 means LED receives power 75% of the time, so brightness is 75%.

2. Step 2: Check code correctness

   Code sets up PWM on pin 18 at 500 Hz, starts at 0, then changes duty cycle to 75 correctly.

3. Final Answer:

   LED will be at 75% brightness -> Option C

4. Quick Check:

   ChangeDutyCycle(75) = 75% brightness [OK]

Hint: Duty cycle % equals brightness % [OK]

Common Mistakes:

• Confusing duty cycle with frequency
• Thinking 0 means full brightness
• Forgetting to start PWM before changing duty

4. Identify the error in this code that controls LED brightness and fix it:

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)
pwm = GPIO.PWM(18, 1000)
pwm.ChangeDutyCycle(50)
pwm.start(50)
GPIO.cleanup()

medium

A. Frequency 1000 is too high, use 100

B. ChangeDutyCycle called before start; swap their order

C. GPIO.cleanup() should be before pwm.start()

D. Missing GPIO.setwarnings(False)

Solution

1. Step 1: Check PWM start and ChangeDutyCycle order

   ChangeDutyCycle must be called after pwm.start(), not before.

2. Step 2: Correct the order

   Swap lines so pwm.start(50) comes before pwm.ChangeDutyCycle(50).

3. Final Answer:

   ChangeDutyCycle called before start; swap their order -> Option B

4. Quick Check:

   start() must come before ChangeDutyCycle() [OK]

Hint: Always start PWM before changing duty cycle [OK]

Common Mistakes:

• Calling ChangeDutyCycle before start
• Cleaning up GPIO too early
• Incorrect frequency assumptions

5. You want to smoothly increase LED brightness from 0% to 100% over 5 seconds using PWM on pin 18. Which code snippet correctly implements this?

hard

A. import time
for dc in range(0, 101):
pwm.ChangeDutyCycle(dc)
time.sleep(0.05)

B. import time
for dc in range(0, 101, 10):
pwm.ChangeDutyCycle(dc)
time.sleep(0.5)

C. import time
for dc in range(0, 101, 20):
pwm.ChangeDutyCycle(dc)
time.sleep(1)

D. import time
for dc in range(0, 51):
pwm.ChangeDutyCycle(dc*2)
time.sleep(0.1)

Solution

1. Step 1: Calculate total steps and delay

   To increase from 0 to 100 in 5 seconds smoothly, small steps with short delay are needed.

2. Step 2: Analyze each option timing

   import time for dc in range(0, 101): pwm.ChangeDutyCycle(dc) time.sleep(0.05) uses 101 steps with 0.05s delay = 5.05s total, smooth increase.

3. Final Answer:

   import time for dc in range(0, 101): pwm.ChangeDutyCycle(dc) time.sleep(0.05) -> Option A

4. Quick Check:

   101 steps * 0.05s = ~5 seconds smooth ramp [OK]

Hint: Use small steps with short delay for smooth brightness [OK]

Common Mistakes:

• Using too few steps causing jumps
• Incorrect total time calculation
• Multiplying duty cycle incorrectly