LED class and methods in Raspberry Pi - Time & Space Complexity

Time Complexity: LED class and methods

O(n)

Understanding Time Complexity

We want to understand how the time it takes to control LEDs grows as we use more LEDs or call methods multiple times.

How does the number of LEDs or method calls affect the total work done?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class LED:
    def __init__(self, pin):
        self.pin = pin
        self.state = False

    def turn_on(self):
        self.state = True

    def turn_off(self):
        self.state = False

leds = [LED(pin) for pin in range(5)]
for led in leds:
    led.turn_on()

This code creates 5 LED objects and turns each one on by calling the turn_on method.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Calling turn_on method on each LED object.
• How many times: Once for each LED in the list (5 times in this example).

How Execution Grows With Input

As the number of LEDs increases, the number of times we call turn_on grows the same way.

Input Size (n)	Approx. Operations
10	10 calls to turn_on
100	100 calls to turn_on
1000	1000 calls to turn_on

Pattern observation: The work grows directly with the number of LEDs.

Final Time Complexity

Time Complexity: O(n)

This means if you double the number of LEDs, the time to turn them all on roughly doubles.

Common Mistake

[X] Wrong: "Turning on multiple LEDs happens all at once, so time stays the same no matter how many LEDs there are."

[OK] Correct: Each LED needs its own method call, so the total time adds up with more LEDs.

Interview Connect

Understanding how loops over objects affect time helps you explain how your code scales when controlling hardware like LEDs.

Self-Check

What if we added a nested loop to blink each LED multiple times? How would the time complexity change?

Practice

1.

What does the on() method of an LED class typically do in Raspberry Pi programming?

easy

A. Turns the LED light on

B. Turns the LED light off

C. Makes the LED blink continuously

D. Cleans up the GPIO pins

Solution

1. Step 1: Understand the purpose of on() method

   The on() method is designed to switch the LED light to the ON state.

2. Step 2: Compare with other methods

   Other methods like off() turn the LED off, and blink() makes it blink. Cleanup is done separately.

3. Final Answer:

   Turns the LED light on -> Option A

4. Quick Check:

   on() means LED ON [OK]

Hint: Remember: on() means light ON, off() means light OFF [OK]

Common Mistakes:

• Confusing on() with off()
• Thinking on() cleans GPIO pins
• Assuming on() makes LED blink

2.

Which of the following is the correct way to create an LED object on GPIO pin 17 using the gpiozero library?

from gpiozero import LED

led = ?

easy

A. LED(17)

B. LED.pin(17)

C. LED[17]

D. LED{17}

Solution

1. Step 1: Recall LED object creation syntax

   In gpiozero, you create an LED by calling LED(pin_number), e.g., LED(17).

2. Step 2: Check other options for syntax errors

   Options A, B, and D use invalid Python syntax for object creation.

3. Final Answer:

   LED(17) -> Option A

4. Quick Check:

   LED(pin) = LED(17) [OK]

Hint: Use parentheses with pin number: LED(17) [OK]

Common Mistakes:

• Using square brackets instead of parentheses
• Trying to call a method like LED.pin()
• Using curly braces which are invalid here

3.

What will be the output of this code snippet controlling an LED?

from gpiozero import LED
from time import sleep

led = LED(22)
led.on()
sleep(1)
led.off()
print('LED state:', led.is_lit)

medium

A. SyntaxError

B. LED state: True

C. LED state: None

D. LED state: False

Solution

1. Step 1: Trace the LED state changes

   The LED is turned on, then after 1 second turned off before printing.

2. Step 2: Check the printed LED state

   After led.off(), led.is_lit is False, so output is 'LED state: False'.

3. Final Answer:

   LED state: False -> Option D

4. Quick Check:

   LED off means is_lit = False [OK]

Hint: Check final LED state after all commands run [OK]

Common Mistakes:

• Assuming LED stays on after off()
• Confusing is_lit property value
• Expecting syntax error due to sleep

4.

Identify the error in this code that tries to blink an LED on pin 5:

from gpiozero import LED
from time import sleep

led = LED(5)
led.blink(on_time=0.5, off_time=0.5)
sleep(2)
led.off()

medium

A. Missing led.on() before blink

B. Should call led.close() to clean GPIO

C. No error; code works correctly

D. blink() method requires a times argument

Solution

1. Step 1: Review the code for GPIO cleanup

   The code blinks the LED and turns it off but does not release GPIO resources.

2. Step 2: Identify missing cleanup step

   Proper practice is to call led.close() to free GPIO pins after use.

3. Final Answer:

   Should call led.close() to clean GPIO -> Option B

4. Quick Check:

   Always close GPIO pins after use [OK]

Hint: Always close() LEDs to free GPIO pins [OK]

Common Mistakes:

• Thinking blink() needs on() first
• Assuming blink() requires times argument
• Ignoring GPIO cleanup after program

5.

You want to create a program that blinks two LEDs on pins 17 and 27 alternately every 0.5 seconds for 5 seconds total. Which code snippet correctly implements this using the LED class?

from gpiozero import LED
from time import sleep

led1 = LED(17)
led2 = LED(27)

start = 0
while start < 5:
    led1.on()
    led2.off()
    sleep(0.5)
    led1.off()
    led2.on()
    sleep(0.5)
    start += 1

led1.off()
led2.off()
led1.close()
led2.close()

hard

A. Should use blink() method instead of manual on/off

B. The loop runs too long; should use start < 10

C. This code blinks LEDs alternately for 5 seconds correctly

D. Missing sleep between led1.off() and led2.on()

Solution

1. Step 1: Analyze the loop timing and LED control

   The loop runs 5 times, each iteration takes 1 second (two 0.5s sleeps), total 5 seconds blinking alternately.

2. Step 2: Check LED on/off sequence and cleanup

   LED1 and LED2 turn on/off alternately with proper sleep delays, and GPIO pins are closed at the end.

3. Final Answer:

   This code blinks LEDs alternately for 5 seconds correctly -> Option C

4. Quick Check:

   Loop count x sleep = total blink time [OK]

Hint: Count loop x sleep to verify total blink time [OK]

Common Mistakes:

• Miscounting total blink duration
• Forgetting to close GPIO pins
• Assuming blink() method is mandatory