Digital Output

Labeled diagram of the general-purpose input-output pins

To communicate with the outside world, the Raspberry Pi has a component called the GPIO, which stands for **General Purpose Input Output**. 

The GPIO is a set of 40 pins that are located on the side of the Raspberry Pi and are used for a variety of hardware applications. 

![A Raspberry Pi 4 with the 40 pin General Purpose Input Output header on the right side.](https://static-assets.codecademy.com/Courses/learn-raspberry-pi/Raspberry_Pi_tall_whbg.png)

As their name suggests, the GPIO pins are capable of both the input and output of data. In this lesson, we will focus on using the GPIO to light up LEDs!

Introduction

In this exercise, we will use Python to light up the LED in the circuit we built in the previous exercise.

You will be working with Python functions in this exercise. If you are not familiar with functions in Python, check out the [Codecademy docs on functions](https://www.codecademy.com/resources/docs/python/functions).

In this next example, let's say we have an LED circuit connected to GPIO24. We initialize the LED class in Python like so:

```py
from gpiozero import LED

led = LED(24)
```

The LED class contains a method that turns an LED on. This method is `.on()` and is called using the instance contained in `led`. You call this method by writing `led.on()`. This will set the state of the GPIO at pin 24 to HIGH.

```py
from gpiozero import LED

led = LED(24)

led.on()
```

To turn the LED off, we set the state of GPIO24 to LOW using: `led.off()`.

```py
from gpiozero import LED

led = LED(24)

led.on() # Turn LED on

led.off() # Turn LED off
```

If you run this piece of code, you will notice that nothing happens to your LED! That is because this code executes so fast, you won’t be able to see the LED turn on then off again. 

To actually see the LED turn on and off we have to put a pause between the `.on()` and `.off()` methods. 

We will import and use `sleep` to stall the execution of code. The syntax is:

```py
from gpiozero import LED
from time import sleep

led = LED(24)

led.on() # Turn LED on
sleep(1)
led.off() # Turn LED off
sleep(1)
```

Toggling LEDs using gpiozero

Great job on making this far in the lesson on digital output! Let’s summarize everything we just learned.

- The Raspberry Pi is capable of communicating with the outside world via its GPIO pins.
- A GPIO pin, when configured in output mode, can only have two states: HIGH (3.3 Volts) or LOW (0 Volts)
- An LED can be connected to the GPIO pin and can be controlled to light up or turn off.
- An LED is connected to a GPIO pin by connecting it in series with a resistor.
- The `LED()` class is used to control an LED connected to the GPIO.

Well done! 


Review

For this lesson, we will be working with circuits that control the state of one or more LEDs. The following schematic is an LED circuit with a pushbutton, where an open button means the LED state is off and a closed button means the LED state is on.

![Circuit schematic with a voltage source, push-button, resistor, and light-emitting diode.](https://static-assets.codecademy.com/Courses/learn-raspberry-pi/elec_full_schematic_e9.png)

Moving to the workspace, we see an implementation of the pushbutton LED circuit. 

The constant 3.3V on GPIO pin 1 is connected to row 5 on the left side of the breadboard. Ground on GPIO pin 20 is connected to row 11 on the right side of the breadboard. These two connections make up the circuit's electric supply. 

A button, a 330Ω resistor, and a red LED are then connected together as the load of the circuit.

Let's say the red LED has the following characteristics:
- V<sub>f</sub> = 1.8V
- I<sub>f</sub> = 0.02A

Using the forward voltage of the LED and 330Ω as the value of the resistor, let's calculate the actual current through the circuit:

```tex
3.3V = 1.8V + V_{resistor}
```
```tex
V_{resistor} = 1.5V
```
Using Ohm's law:

```tex
I = V ÷ R
```
```tex
I = 1.5V ÷ 330Ω
```

```tex
I = 0.0045A
```

Even though the LED has a forward current of 0.02A, our current limiting 330Ω resistor has brought the current in this circuit down to 0.0045A! Why is that?  

The higher value resistor is recommended to avoid damaging the Raspberry Pi circuit components. The Raspberry Pi can not provide a lot of current (0.02A might be too high!) To be safe we used a larger resistor value and in return, we will get a slightly dimmer LED.

A Raspberry Pi and breadboard circuit with a constant 3.3V electric source, a pushbutton, a 330 ohm resistor, and an LED.

Connecting LEDs to GPIO Pins

Good work getting to this point. We can now use what we've learned to light up a few LEDs!

Since each `LED` instance is attached to a single GPIO pin, we can now create multiple instances each with its own pin.
```py
from gpiozero import LED
from time import sleep

led1 = LED(1)
led2 = LED(2)

led1.on()
sleep(1)
led1.off()
led2.on()
sleep(1)
led2.off()
```
From the example above we can see that controlling two LEDs involves instantiating a new `LED` class with a different pin. If you try and instantiate with a pin already assigned you'll receive an error.

The 2nd part of the code example turns the first LED on, then off - then the second LED is turned on, then off. 

Be aware that turning on too many LEDs using a real Raspberry Pi can result in damage to the board. That is why we are just lighting up one at a time.

Now give this a try yourself!

Multiple LEDs

A pin on the Raspberry Pi can be used as an output, meaning that it can "send" an electrical signal to the outside world. 

When used as an output, a GPIO pin on the Raspberry Pi is capable of only being in two states: HIGH or LOW. 

A pin in the HIGH state means it provides 3.3V in reference to Ground. This is the equivalent of connecting something to the positive side of a 3.3V battery. 

A pin in the LOW state means the pin provides 0 volts. This is the equivalent of connecting something directly to Ground. 

![Labeled diagram of the general-purpose input-output pins](https://static-assets.codecademy.com/Courses/learn-raspberry-pi/do_GPIO_labels_sm.png)

Looking at the above diagram again, we can see there are a few pins on the GPIO port that are dedicated to being either HIGH or LOW (you can’t change their state). These are the 3.3V and Ground pins. 

The rest of the pins are numbered GPIO pins that can be designated HIGH or LOW by software on the Raspberry Pi. 

In the next exercise, we will turn the LED on and off by changing the state of the GPIO pin using the programming language Python.

GPIO Pin States

To use the GPIO pins as output, we need to use the Python module `gpiozero`. This library is already installed in the workspace so you can use it immediately. 

If you own a Raspberry Pi, the `gpiozero` library may already be installed; however, if it is not, you can install it by running the following command in the terminal:

>`pip3 install gpiozero`

Refer to [the gpiozero documentation](https://gpiozero.readthedocs.io/en/stable/) for more information.

To use the `gpiozero` module in our code, we have to write this line at the top of the script:

```py
from gpiozero import LED
```
This line instructs Python to bring in all the necessary code that we need to work with LEDs. 

The `gpiozero` is known as a **module** which contains prewritten code that we can use. Reference the [Codecademy doc on modules](https://www.codecademy.com/resources/docs/python/modules) for further explanation. 

The `LED` instructs Python to import the LED class which represents an LED in Python. To use the LED class, we create a variable called `light` and assign to it an LED object like so:

```py
from gpiozero import LED

light = LED(10)
```

The variable `light` holds an *instance* of the `LED` class. A class is the design of an object, the instance is the object itself. Classes contain variables and functions that you can access and use. Each instance of a class will have its own copy of these variables and functions!

Reference the [Codecademy doc on classes](https://www.codecademy.com/resources/docs/python/classes) for further explanation.

The keyword `LED(10)` instructs Python that there is an LED connected to pin 10 of the Raspberry Pi GPIO. 

In the next exercise, we will see how we can turn the LED on and off.
