PWM frequency and duty cycle relationship in Raspberry Pi - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

PWM Duty Cycle Calculation Output

What is the output of this Python code that calculates the duty cycle percentage for a PWM signal?

Raspberry Pi

frequency = 1000  # 1 kHz
period = 1 / frequency  # seconds
pulse_width = 0.00025  # 250 microseconds

duty_cycle = (pulse_width / period) * 100
print(f"Duty cycle: {duty_cycle:.1f}%")

A Duty cycle: 250.0%

B Duty cycle: 2.5%

C Duty cycle: 0.25%

D Duty cycle: 25.0%

💡 Hint

Duty cycle is pulse width divided by period times 100.

The period is 1/1000 = 0.001 seconds. The pulse width is 0.00025 seconds. So duty cycle = (0.00025 / 0.001) * 100 = 25%.

🧠 Conceptual

intermediate

Effect of Increasing PWM Frequency on Duty Cycle

If you keep the pulse width constant but increase the PWM frequency, what happens to the duty cycle?

A Duty cycle decreases because the period gets shorter.

B Duty cycle stays the same because pulse width is constant.

C Duty cycle increases because the period gets longer.

D Duty cycle becomes zero because frequency is too high.

💡 Hint

Duty cycle = pulse width / period. What happens to period when frequency increases?

Increasing frequency makes the period shorter. Since pulse width is constant, duty cycle = pulse width / smaller period, so duty cycle increases.

🔧 Debug

advanced

Identify the Error in PWM Duty Cycle Calculation

What error does this code raise when calculating PWM duty cycle?

Raspberry Pi

frequency = 0
period = 1 / frequency
pulse_width = 0.0005

duty_cycle = (pulse_width / period) * 100
print(f"Duty cycle: {duty_cycle}%")

A ZeroDivisionError

B TypeError

C NameError

D No error, prints duty cycle

💡 Hint

What happens if you divide by zero in Python?

frequency is zero, so 1 / frequency causes ZeroDivisionError.

📝 Syntax

advanced

Syntax Error in PWM Duty Cycle Code

Which option contains a syntax error in the PWM duty cycle calculation?

Raspberry Pi

frequency = 500
period = 1 / frequency
pulse_width = 0.0005
duty_cycle = (pulse_width / period) * 100
print(f"Duty cycle: {duty_cycle}%")

A duty_cycle = pulse_width / period * 100

B duty_cycle = pulse_width / (period * 100

C duty_cycle = (pulse_width / period) * 100

D 001 * )doirep / htdiw_eslup( = elcyc_ytud

💡 Hint

Check for missing parentheses.

Option B is missing a closing parenthesis, causing a SyntaxError.

🚀 Application

expert

Calculate PWM Frequency from Duty Cycle and Pulse Width

Given a PWM signal with a pulse width of 0.0001 seconds and a duty cycle of 10%, what is the PWM frequency?

A 10,000 Hz

B 1,000,000 Hz

C 1000 Hz

D 100 Hz

💡 Hint

Use formula: duty cycle = pulse width / period * 100, then find frequency = 1 / period.

Duty cycle = 10% = 0.1, pulse width = 0.0001 s. So period = pulse width / duty cycle = 0.0001 / 0.1 = 0.001 s. Frequency = 1 / 0.001 = 1000 Hz. But 1000 Hz is option C, check carefully. Actually, 0.0001 / period = 0.1 → period = 0.0001 / 0.1 = 0.001 s → frequency = 1 / 0.001 = 1000 Hz. So correct answer is A.

Practice

1. What does the duty cycle in PWM control on a Raspberry Pi?

easy

A. The percentage of time the signal is ON during one cycle

B. The speed at which the signal pulses repeat

C. The voltage level of the signal

D. The total duration of the PWM signal

Solution

1. Step 1: Understand duty cycle meaning

   The duty cycle is the fraction of one cycle when the signal is ON (high).

2. Step 2: Differentiate from frequency

   Frequency controls how fast cycles repeat, not how long signal stays ON.

3. Final Answer:

   The percentage of time the signal is ON during one cycle -> Option A

4. Quick Check:

   Duty cycle = ON time percentage [OK]

Hint: Duty cycle = ON time percentage in each pulse [OK]

Common Mistakes:

• Confusing duty cycle with frequency
• Thinking duty cycle controls voltage
• Assuming duty cycle affects total signal duration

2. Which of the following is the correct Python syntax to set a PWM frequency to 1000 Hz on a Raspberry Pi GPIO pin using RPi.GPIO?

easy

A. pwm = GPIO.PWM(pin, 1000)

B. pwm = GPIO.setPWM(pin, 1000)

C. pwm = GPIO.PWM(pin).frequency(1000)

D. pwm = GPIO.frequency(pin, 1000)

Solution

1. Step 1: Recall RPi.GPIO PWM syntax

   The correct way to create a PWM instance is GPIO.PWM(pin, frequency).

2. Step 2: Check options for correct method and parameters

   pwm = GPIO.PWM(pin, 1000) matches the correct syntax; others use invalid methods or chaining.

3. Final Answer:

   pwm = GPIO.PWM(pin, 1000) -> Option A

4. Quick Check:

   GPIO.PWM(pin, freq) creates PWM [OK]

Hint: Use GPIO.PWM(pin, frequency) to set PWM frequency [OK]

Common Mistakes:

• Using non-existent methods like setPWM or frequency()
• Trying to set frequency after creating PWM without parameters
• Confusing method chaining syntax

3. Consider this Python code snippet controlling an LED brightness with PWM on Raspberry Pi:

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

What is the effect of setting the duty cycle to 75%?

medium

A. LED will be off

B. LED will be at full brightness

C. LED will blink 75 times per second

D. LED will be at 75% brightness

Solution

1. Step 1: Understand duty cycle effect on LED brightness

   Duty cycle of 75% means LED is ON 75% of the time, so brightness is about 75%.

2. Step 2: Confirm frequency and duty cycle usage

   Frequency 500 Hz controls pulse speed; duty cycle controls brightness level.

3. Final Answer:

   LED will be at 75% brightness -> Option D

4. Quick Check:

   Duty cycle 75% = 75% brightness [OK]

Hint: Duty cycle % roughly equals LED brightness % [OK]

Common Mistakes:

• Confusing frequency with blinking count
• Thinking duty cycle 75 means LED off
• Assuming full brightness only at 100% duty cycle

4. This code tries to change PWM frequency on Raspberry Pi but does not work as expected:

pwm = GPIO.PWM(18, 1000)
pwm.start(50)
pwm.changeFrequency(2000)

What is the error and how to fix it?

medium

A. ChangeFrequency is not a valid method; use pwm.ChangeFrequency(2000)

B. ChangeFrequency method name is incorrect; use pwm.ChangeFrequency(2000)

C. Frequency cannot be changed after PWM.start(); recreate PWM object

D. Method name is case sensitive; use pwm.ChangeFrequency(2000)

Solution

1. Step 1: Identify method name case sensitivity

   RPi.GPIO does not provide a method to change frequency after PWM object creation.

2. Step 2: Correct approach to change frequency

   To change frequency, stop PWM and create a new PWM instance with the new frequency.

3. Final Answer:

   Frequency cannot be changed after PWM.start(); recreate PWM object -> Option C

4. Quick Check:

   RPi.GPIO PWM frequency fixed at creation [OK]

Hint: To change frequency, recreate PWM object [OK]

Common Mistakes:

• Using wrong method name spelling
• Ignoring case sensitivity in Python
• Trying to change frequency by creating new PWM instance

5. You want to control a motor speed using PWM on Raspberry Pi. The motor requires a minimum frequency of 1000 Hz for smooth operation. If you set frequency to 1000 Hz and duty cycle to 20%, what happens if you increase frequency to 2000 Hz but keep duty cycle at 20%?

hard

A. Motor speed doubles because frequency doubled

B. Motor speed stays roughly the same because duty cycle is unchanged

C. Motor stops because frequency is too high

D. Motor speed halves because frequency doubled

Solution

1. Step 1: Understand frequency vs duty cycle effect on motor speed

   Motor speed depends mainly on duty cycle (power ON time), not frequency.

2. Step 2: Analyze frequency change with constant duty cycle

   Increasing frequency while keeping duty cycle constant keeps average power same, so speed stays similar.

3. Final Answer:

   Motor speed stays roughly the same because duty cycle is unchanged -> Option B

4. Quick Check:

   Speed ~ duty cycle, frequency affects smoothness [OK]

Hint: Motor speed depends on duty cycle, not frequency [OK]

Common Mistakes:

• Assuming frequency change affects speed directly
• Thinking doubling frequency doubles speed
• Ignoring duty cycle's role in power delivery