GPIO cleanup on exit in Raspberry Pi - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the GPIO library.

Raspberry Pi

import [1]

Drag options to blanks, or click blank then click option'

ARPi.GPIO as GPIO

Bos

Ctime

Dsys

Attempts:

3 left

💡 Hint

Common Mistakes

Importing 'time' instead of the GPIO library.

Forgetting to alias the library as GPIO.

The Raspberry Pi GPIO library is imported as RPi.GPIO as GPIO to control the pins easily.

2fill in blank

medium

Complete the code to set the GPIO mode to BCM.

Raspberry Pi

GPIO.setmode([1])

Drag options to blanks, or click blank then click option'

AGPIO.BOARD

BGPIO.IN

CGPIO.OUT

DGPIO.BCM

Attempts:

3 left

💡 Hint

Common Mistakes

Using GPIO.BOARD instead of GPIO.BCM.

Confusing input/output modes with pin numbering modes.

Setting GPIO mode to GPIO.BCM means you use the Broadcom chip pin numbers.

3fill in blank

hard

Fix the error in the code to clean up GPIO on program exit.

Raspberry Pi

try:
    # Your code here
    pass
finally:
    [1]()

Drag options to blanks, or click blank then click option'

AGPIO.setup

BGPIO.setmode

CGPIO.cleanup

DGPIO.output

Attempts:

3 left

💡 Hint

Common Mistakes

Calling GPIO.setmode() instead of cleanup.

Forgetting to call cleanup leading to warnings.

The GPIO.cleanup() function resets all GPIO pins used by the program, preventing warnings on next run.

4fill in blank

hard

Fill both blanks to set up a GPIO pin 18 as output and then clean up on exit.

Raspberry Pi

GPIO.setup([1], [2])
try:
    # Use the pin
    pass
finally:
    GPIO.cleanup()

Drag options to blanks, or click blank then click option'

A18

BGPIO.OUT

CGPIO.IN

D17

Attempts:

3 left

💡 Hint

Common Mistakes

Using pin 17 instead of 18.

Setting pin mode to GPIO.IN instead of GPIO.OUT.

Pin 18 is set as an output pin using GPIO.OUT. Cleanup is called after usage.

5fill in blank

hard

Fill all three blanks to write a high signal to pin 23, then clean up GPIO on exit.

Raspberry Pi

GPIO.setup([1], [2])
GPIO.output([3], GPIO.HIGH)
try:
    pass
finally:
    GPIO.cleanup()

Drag options to blanks, or click blank then click option'

A23

BGPIO.OUT

D18

Attempts:

3 left

💡 Hint

Common Mistakes

Using pin 18 instead of 23.

Forgetting to set pin mode before output.

Pin 23 is set as output, then set to HIGH signal. Cleanup resets pins on exit.

Practice

1. Why is it important to call GPIO.cleanup() at the end of a Raspberry Pi GPIO program?

easy

A. It resets the GPIO pins to a safe state for future use.

B. It speeds up the program execution.

C. It increases the voltage output of the pins.

D. It disables the Raspberry Pi's network connection.

Solution

1. Step 1: Understand GPIO pin states

   GPIO pins can remain set as input or output after a program ends, which may cause issues.

2. Step 2: Purpose of GPIO.cleanup()

   Calling GPIO.cleanup() resets all pins to their default safe state, preventing conflicts in future programs.

3. Final Answer:

   It resets the GPIO pins to a safe state for future use. -> Option A

4. Quick Check:

   GPIO.cleanup() resets pins = B [OK]

Hint: Always reset pins with GPIO.cleanup() after use [OK]

Common Mistakes:

• Thinking cleanup speeds up code
• Believing cleanup changes voltage
• Confusing cleanup with network settings

2. Which of the following is the correct way to ensure GPIO.cleanup() runs even if your program encounters an error?

easy

A. Place GPIO.cleanup() inside a try block only.

B. Place GPIO.cleanup() inside a finally block.

C. Call GPIO.cleanup() before setting up pins.

D. Call GPIO.cleanup() only if no errors occur.

Solution

1. Step 1: Understand try-finally structure

   The finally block runs no matter what, even if errors happen.

2. Step 2: Place cleanup in finally

   Putting GPIO.cleanup() in finally ensures pins reset even on exceptions.

3. Final Answer:

   Place GPIO.cleanup() inside a finally block. -> Option B

4. Quick Check:

   Cleanup in finally = A [OK]

Hint: Use finally block to always run cleanup [OK]

Common Mistakes:

• Putting cleanup only in try block
• Calling cleanup before setup
• Skipping cleanup on errors

3. What will be the output of this code snippet if an error occurs during the loop?

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)
try:
    for i in range(3):
        if i == 1:
            raise Exception('Error!')
        GPIO.output(18, GPIO.HIGH)
finally:
    GPIO.cleanup()
print('Program ended')

medium

A. Program ended

B. GPIO pins remain set high

C. No output, program hangs

D. Exception: Error!

Solution

1. Step 1: Analyze try block with error

   The loop raises an exception at i=1, but the finally block still runs.

2. Step 2: Effect of finally block

   GPIO.cleanup() runs regardless, resetting pins, but since there is no except block, the exception propagates after finally, so print('Program ended') does not execute. The output is the exception message.

3. Final Answer:

   Exception: Error! -> Option D

4. Quick Check:

   finally runs cleanup, exception prints = B [OK]

Hint: finally block runs even on errors [OK]

Common Mistakes:

• Thinking 'Program ended' prints on error
• Thinking pins stay set after error
• Ignoring finally block execution

4. Identify the error in this code that prevents GPIO pins from being cleaned up properly:

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.OUT)
try:
    GPIO.output(17, GPIO.HIGH)
except:
    print('Error occurred')
finally:
    GPIO.cleanup()

medium

A. Missing parentheses after GPIO.cleanup in finally block.

B. GPIO.setup should be called after GPIO.cleanup.

C. GPIO.output should be inside except block.

D. No try-except block needed for GPIO.

Solution

1. Step 1: Check finally block syntax

   The code uses GPIO.cleanup without parentheses, so cleanup is not called.

2. Step 2: Effect of missing parentheses

   Without parentheses, cleanup is a reference, not a function call, so pins are not reset.

3. Final Answer:

   Missing parentheses after GPIO.cleanup in finally block. -> Option A

4. Quick Check:

   Call cleanup with () = D [OK]

Hint: Always add () to call GPIO.cleanup() [OK]

Common Mistakes:

• Forgetting parentheses on cleanup
• Calling setup after cleanup
• Misplacing GPIO.output inside except

5. You wrote a program controlling multiple GPIO pins with different modes. How should you structure your code to ensure all pins reset properly even if your program crashes unexpectedly?

hard

A. Use GPIO.cleanup() inside except block only.

B. Call GPIO.cleanup() only at the very start of the program.

C. Place all GPIO setup and output calls inside a try block, and call GPIO.cleanup() in a finally block.

D. Do not use GPIO.cleanup() to avoid resetting pins.

Solution

1. Step 1: Organize GPIO code with try-finally

   Put all GPIO setup and control inside try to catch errors and ensure cleanup.

2. Step 2: Use finally block for cleanup

   Call GPIO.cleanup() in finally so it runs no matter what, resetting all pins safely.

3. Final Answer:

   Place all GPIO setup and output calls inside a try block, and call GPIO.cleanup() in a finally block. -> Option C

4. Quick Check:

   try-finally with cleanup = C [OK]

Hint: Use try-finally to guarantee cleanup on exit [OK]

Common Mistakes:

• Calling cleanup only at start
• Skipping cleanup on errors
• Avoiding cleanup to keep pins set