LED brightness control in Raspberry Pi - Mini Project: Build & Apply

LED brightness control

📖 Scenario: You have a Raspberry Pi connected to an LED light. You want to control how bright the LED is by changing its brightness level.

🎯 Goal: Build a simple program that sets up the LED pin, defines a brightness level, changes the LED brightness using PWM, and then shows the brightness level.

📋 What You'll Learn

Use the RPi.GPIO library to control the LED

Set up the GPIO pin 18 for PWM output

Define a brightness level between 0 and 100

Use PWM to set the LED brightness

Print the brightness level to the screen

💡 Why This Matters

🌍 Real World

Controlling LED brightness is useful in projects like mood lighting, indicators, or displays.

💼 Career

Understanding GPIO and PWM control is important for hardware programming and embedded systems jobs.

1

Set up GPIO and LED pin

Import the RPi.GPIO library as GPIO. Set the GPIO mode to GPIO.BCM. Set up GPIO pin 18 as an output pin.

Raspberry Pi

# Your code here

Hint

Use GPIO.setmode(GPIO.BCM) to select pin numbering. Use GPIO.setup(18, GPIO.OUT) to prepare pin 18 for output.

2

Create PWM instance and set brightness level

Create a PWM instance called pwm on pin 18 with frequency 1000 Hz. Define a variable called brightness and set it to 75.

Raspberry Pi

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)
# Your code here

Hint

Use GPIO.PWM(18, 1000) to create PWM on pin 18 at 1000 Hz. Set brightness to 75 to represent 75% brightness.

3

Start PWM and set duty cycle

Start the PWM with a duty cycle of 0. Then change the duty cycle to the value of brightness to set the LED brightness.

Raspberry Pi

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)
pwm = GPIO.PWM(18, 1000)
brightness = 75
# Your code here

Hint

Use pwm.start(0) to start PWM with 0% brightness, then pwm.ChangeDutyCycle(brightness) to set brightness to 75%.

4

Print the brightness level

Print the message "LED brightness is set to: " followed by the value of brightness.

Raspberry Pi

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)
pwm = GPIO.PWM(18, 1000)
brightness = 75
pwm.start(0)
pwm.ChangeDutyCycle(brightness)
# Your code here

Hint

Use print(f"LED brightness is set to: {brightness}") to show the brightness level.

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