# Raspberry Pi E-Ink Weather Station using Python

## Overview

![](https://cdn-learn.adafruit.com/assets/assets/000/094/192/medium800/raspberry_pi_eink_bonnet.jpeg?1597769183)

With this project, you will always know what the weather is. The eInk Bonnet or Breakout will always let you know what the weather is. If you lose power to your Raspberry Pi or other single board computer, you will still be able to see what the latest weather update is because the ePaper display still shows the last thing written to it!

Using Python, this project queries the Open Weather Maps site API to find out the current weather for your location and displays it along with an informative icon.

This project makes use of the meteocons True Type Font to display the icon, so there are no actual images used in this project.

## Parts

To run this, you will need a Single Board Computer such as the Raspberry Pi.

### Raspberry Pi 4 Model B - 4 GB RAM

[Raspberry Pi 4 Model B - 4 GB RAM](https://www.adafruit.com/product/4296)
The Raspberry Pi 4 Model B is the newest Raspberry Pi computer made, and the Pi Foundation knows you can always make a good thing _better_! And what could make the Pi 4 better than the 3? How about a _faster_ processor, USB 3.0 ports, and updated Gigabit Ethernet chip with...

In Stock
[Buy Now](https://www.adafruit.com/product/4296)
[Related Guides to the Product](https://learn.adafruit.com/products/4296/guides)
![Angled shot of Raspberry Pi 4](https://cdn-shop.adafruit.com/640x480/4296-11.jpg)

You will need a 2.13" Monochrome eInk display such as the eInk Bonnet or the eInk Breakout.

### Adafruit 2.13" Monochrome eInk / ePaper Display with SRAM

[Adafruit 2.13" Monochrome eInk / ePaper Display with SRAM](https://www.adafruit.com/product/4197)
Easy e-paper finally comes to microcontrollers, with this breakout that's designed to make it a breeze to add a monochromatic eInk display. Chances are you've seen one of those new-fangled 'e-readers' like the Kindle or Nook. They have gigantic electronic paper 'static'...

In Stock
[Buy Now](https://www.adafruit.com/product/4197)
[Related Guides to the Product](https://learn.adafruit.com/products/4197/guides)
![Front of E-Ink display with monochrome graphic and "2.13 inch E-Ink Monochrome" text](https://cdn-shop.adafruit.com/640x480/4197-07.jpg)

If you use a breakout board, you will need a few additional parts. First you will need some tactile switches for buttons:

### Tactile Button switch (6mm) x 20 pack

[Tactile Button switch (6mm) x 20 pack](https://www.adafruit.com/product/367)
Little clicky switches are standard input "buttons" on electronic projects. These work best in a PCB but [can be used on a solderless breadboard as shown in this tutorial](https://learn.adafruit.com/adafruit-arduino-lesson-6-digital-inputs?view=all). The pins are normally...

In Stock
[Buy Now](https://www.adafruit.com/product/367)
[Related Guides to the Product](https://learn.adafruit.com/products/367/guides)
![angled shot of 20 6mm mini tactile button switches.](https://cdn-shop.adafruit.com/640x480/367-01.jpg)

You will also needs a couple of 100K Resistors:

### Through-Hole Resistors - 100K ohm 5% 1/4W - Pack of 25

[Through-Hole Resistors - 100K ohm 5% 1/4W - Pack of 25](https://www.adafruit.com/product/2787)
ΩMG! You're not going to be able to resist these handy resistor packs! Well, axially, they do all of the resisting for you!

This is a **25 Pack of 100K Ω Resistors.** More specifically, they are **carbon film** , through-hole...

In Stock
[Buy Now](https://www.adafruit.com/product/2787)
[Related Guides to the Product](https://learn.adafruit.com/products/2787/guides)
![Angled shot of 25 Through-Hole Resistors - 100K ohm 5% 1/4W.](https://cdn-shop.adafruit.com/640x480/2787-00.jpg)

### Part: Full sized breadboard
quantity: 1
Breadboard for assembling parts
[Full sized breadboard](https://www.adafruit.com/product/239)

### Part: Premium Male/Male Jumper Wires - 40 x 6" (150mm)
quantity: 1
Handy for making wire harnesses or jumpering between headers on PCB's.
[Premium Male/Male Jumper Wires - 40 x 6" (150mm)](https://www.adafruit.com/product/758)

### Part: Stacking Header for Pi A+/B+/Pi 2/Pi 3 - 2x20 Extra Tall Header
quantity: 1
Header for adding bonnets without interfering with Pi cooling
[Stacking Header for Pi A+/B+/Pi 2/Pi 3 - 2x20 Extra Tall Header](https://www.adafruit.com/product/1979)

# Raspberry Pi E-Ink Weather Station using Python

## Display Versions

 **As of May 1, 2021** - we are now selling this bonnet with an E-Ink display that uses the SSD1680 chipset as the SSD1675 is discontinued/unavailable. The resolution and size are the same, but firmware/python code will need to be updated to use the SSD1680-driver in our library rather than SSD1675!

**As of October 2022**  - we've updated this PCB with **[Adafruit Pinguin](https://github.com/adafruit/Adafruit_Pinguin)** to make a lovely and legible silkscreen - you may get the new PCB or the older version with vector fonts - both are identical other than the fancy silkscreen. Additionally, this bonnet may come with a  black or tan STEMMA QT connector. They work the same!

**As of August 21, 2024**  - The old 2.13" display has been discontinued, we're now shipping with the GDEY0213B74 which is still an SSD1680 but has 16-pixel offset when configuring the memory layout. This is the SSD1680Z.

Because of the different chipsets, you will need to be able to choose the correct driver for the display you will be using it with. It's easy to tell the difference if you know what to look for. 

On the eInk display itself, the SSD1675 version has two tabs on the righthand side:

![](https://cdn-learn.adafruit.com/assets/assets/000/122/348/medium800/adafruit_products_SSD1675.jpg?1688749731)

The SSD1680 version has only a single tab on the righthand side:

![](https://cdn-learn.adafruit.com/assets/assets/000/122/349/medium800/adafruit_products_SSD1680.jpg?1688749746)

The SSD1680Z with GDEY0213B74 has a larger radius in the area by the tab where the ribbon cable is connected. The 4 corners of the main display area are also slightly rounded:

![](https://cdn-learn.adafruit.com/assets/assets/000/137/054/medium800/adafruit_products_SSD1680Z.jpg?1747935352)

# Raspberry Pi E-Ink Weather Station using Python

## Python Setup

## Wiring

It's easy to use eInk breakouts and bonnets with Python and the [Adafruit CircuitPython EPD](https://github.com/adafruit/Adafruit_CircuitPython_EPD) module. This module allows you to easily write Python code to control the display.

### Using the eInk Bonnet

Since the eInk Bonnet comes preassembled, all you need to do is place it onto the GPIO pins.

Since there's _dozens_ of Linux computers/boards you can use we will show wiring for Raspberry Pi. For other platforms, [please visit the guide for CircuitPython on Linux to see whether your platform is supported](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux). 

Connect the display as shown below to your Raspberry Pi.

![](https://cdn-learn.adafruit.com/assets/assets/000/094/188/medium800/raspberry_pi_4687-05.jpg?1597764528)

### Using an eInk Breakout

Alternatively, if you have a 2.13" Monochrome eInk Display available, you can wire it up along with a couple of buttons and resistors. There's a lot of wires, which is why we recommend using the bonnet.

- **3V Rail** connects to the Pi's **3V**  pin
- eInk **VIN** connects to the **3V Rail** 
- eInk **GND**  connects to the Pi's  **ground**
- eInk **CLK**  connects to SPI clock. On the Pi, thats  **SLCK**
- eInk **MOSI**  connects to SPI MOSI. On the Pi, thats also  **MOSI**
- eInk **ECS**  connects to our SPI Chip Select pin. We'll be using  **CE0**
- eInk **D/C**  connects to our SPI Chip Select pin. We'll be using  **GPIO 22**.
- eInk **RST**  connects to our Reset pin. We'll be using  **GPIO 13**.
- **GPIO 5** connects to one side of a tactile switch.
- **GPIO 6** connects to one side of the other tactile switch.
- Place a **100KΩ** resistor between **GPIO5** and the **+3V rail**.
- Place a **100KΩ** resistor between **GPIO6**  and the **+3V rail**.
- Connect the other side of each tactile switch to the Pi's **ground**.

![raspberry_pi_breakout_bb.jpg](https://cdn-learn.adafruit.com/assets/assets/000/093/100/medium640/raspberry_pi_breakout_bb.jpg?1594686262)

Info: 

Warning: 

## Software Setup

You'll need to install the Adafruit\_Blinka library that provides the CircuitPython support in Python. This may also require enabling SPI on your platform and verifying you are running Python 3. [Since each platform is a little different, and Linux changes often, please visit the CircuitPython on Linux guide to get your computer ready](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux)!

Danger: 

## Python Installation of EPD Library

Once that's done, from your command line with your virtual environment active, run the following command:

```terminal
pip3 install adafruit-circuitpython-epd
```

If your default Python is version 3 you may need to run 'pip' instead. Just make sure you aren't trying to use CircuitPython on Python 2.x, it isn't supported!

If that complains about pip3 not being installed, then run this first to install it:

```terminal
sudo apt install python3-pip
```

## DejaVu TTF Font

Raspberry Pi usually comes with the DejaVu font already installed, but in case it didn't, you can run the following to install it:

```terminal
sudo apt install fonts-dejavu
```

This package was previously calls **ttf-dejavu** , so if you are running an older version of Raspberry Pi OS, it may be called that.

## Pillow Library

We also need PIL, the Python Imaging Library, to allow graphics and using text with custom fonts. There are several system libraries that PIL relies on, so installing via a package manager is the easiest way to bring in everything:

```terminal
sudo apt install python3-pil
```

That's it. You should be ready to go!

# Raspberry Pi E-Ink Weather Station using Python

## Weather Station Code

## Open Weather Map API Key

This uses the OpenWeatherMap.org to retrieve the weather info through its API. In order to do so, you'll need to register for an account and get an API key.

Go to this [link](https://home.openweathermap.org/users/sign_up) and register for a free account. Once registered, you'll get an email containing your API key, also known as the "openweather token".

## Python Code

The code for this project was based off the code available in the [PyPortal Weather Station](https://learn.adafruit.com/pyportal-weather-station) guide, though the graphics portion of this project works quite differently. Go ahead and download the project and we'll go over the code.

The files you will need are **code.py** , **weather\_graphics.py** , and **meteocons.ttf**. They should all be placed in the same folder.

https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/EInk_Bonnet_Weather_Station/code.py

To start with, look for this line in the code and be sure to enter your `OPEN_WEATHER_TOKEN`:

```python
# You'll need to get a token from openweathermap.org, looks like:
# 'b6907d289e10d714a6e88b30761fae22'
OPEN_WEATHER_TOKEN = ""
```

Next, look for this line in the code and set the `LOCATION` variable to your location:

```python
# Use cityname, country code where countrycode is ISO3166 format.
# E.g. "New York, US" or "London, GB"
LOCATION = "Manhattan, US"
```

To run the example, upload **code.py** , **weather\_graphics.py** , and **meteocons.ttf** to the same directory and use the following command:

`python3 code.py`

You should see an output similar to this:

![](https://cdn-learn.adafruit.com/assets/assets/000/094/191/medium800/raspberry_pi_eInk_bonnet_zoomed.jpeg?1597769158)

## Automation Changes

If you would like to run the weather script in a Cron job or to run on start up, you may find it easier to move the **meteocons.ttf** file to a more central place.

A good place to put it would be to create a folder named **meteocons** inside of in **/usr/share/fonts/truetype** and then move the **meteocons.ttf** file inside of that folder.

You'll also need to change the location of the file inside of **weather\_graphics.py**.

## How It Works

There are two files that are used. First is the main file, which is the one you will use to to run the example.

### Main File

First start by loading any libraries that are used. The notable libraries are  **urllib** , **adafruit\_epd** , **weather\_graphics**. The library called **urllib** is a built-in library used for retrieving and parsing data from the internet. The **adafruit\_epd** library is used to initialize and write data to the ePaper Display, and the **weather\_graphics** is the portion of code that will handle any graphics.

```python
import time
import urllib.request
import urllib.parse
import digitalio
import busio
import board
from adafruit_epd.ssd1680 import Adafruit_SSD1680Z
from adafruit_epd.ssd1675 import Adafruit_SSD1675
from adafruit_epd.ssd1680 import Adafruit_SSD1680
from weather_graphics import Weather_Graphics
```

Now to set up SPI and any pins used. If you are using the EInk bonnet or have wired it up like in the setup page, you shouldn't need to change anything unless you are using a different board than the Raspberry Pi.

```python
spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
ecs = digitalio.DigitalInOut(board.CE0)
dc = digitalio.DigitalInOut(board.D22)
rst = digitalio.DigitalInOut(board.D27)
busy = digitalio.DigitalInOut(board.D17)
```

The next section contains the parameters used for connecting to Open Weather. You should have already filled in the token and location, and if not, take a look at the beginning of this page.

```python
# You'll need to get a token from openweathermap.org, looks like:
# 'b6907d289e10d714a6e88b30761fae22'
OPEN_WEATHER_TOKEN = ""

# Use cityname, country code where countrycode is ISO3166 format.
# E.g. "New York, US" or "London, GB"
LOCATION = "Manhattan, US"
DATA_SOURCE_URL = "http://api.openweathermap.org/data/2.5/weather"
```

The next section just checks to make sure you've added the token and assembles the URL with the parameters.

```python
if len(OPEN_WEATHER_TOKEN) == 0:
    raise RuntimeError(
        "You need to set your token first. If you don't already have one, you can register for a free account at https://home.openweathermap.org/users/sign_up"
    )

# Set up where we'll be fetching data from
params = {"q": LOCATION, "appid": OPEN_WEATHER_TOKEN}
data_source = DATA_SOURCE_URL + "?" + urllib.parse.urlencode(params)
```

After that is to set up the ePaper display and set the rotation. If you are using an older eInk Bonnet, you will need to comment out the line for the newer bonnet and uncomment the one for the older bonnet.

```python
# Initialize the Display
display = Adafruit_SSD1680Z(     # New Bonnet ssd1680z [GDEY0213B74]
# display = Adafruit_SSD1680_Legacy( # pre-2024 SSD1680 Bonnet
#display = Adafruit_SSD1680(     # Old eInk Bonnet ssd1680
#display = Adafruit_SSD1675(   # Older eInk Bonnet ssd1675
#    122, 250, spi, cs_pin=ecs, dc_pin=dc, sramcs_pin=None, rst_pin=rst, busy_pin=busy,
    120, 250, spi, cs_pin=ecs, dc_pin=dc, sramcs_pin=None, rst_pin=rst, busy_pin=busy,

)

display.rotation = 1
```

Next is to initialize the Graphics library and initialize the `weather_refresh` variable with a default value. The `weather_refresh` variable is used to determine the last time that the weather data was refreshed so that there can be 2 different timing loops for weather and time.

```python
gfx = Weather_Graphics(display, am_pm=True, celsius=False)
weather_refresh = None
```

Finally, the main code loop checks to see if the weather data has been retrieved at all or that at least 600 seconds (10 minutes) have passed since the last time it was refreshed. If either condition is met, it uses `urllib` to get the data from the Open Weather URL. It then updates the time (as well as the display) using the weather graphics and waits for 300 seconds (5 minutes) so that the display isn't refreshed too often, which can cause the eInk displays to fail prematurely.

```python
while True:
    # only query the weather every 10 minutes (and on first run)
    if (not weather_refresh) or (time.monotonic() - weather_refresh) > 600:
        response = urllib.request.urlopen(data_source)
        if response.getcode() == 200:
            value = response.read()
            print("Response is", value)
            gfx.display_weather(value)
            weather_refresh = time.monotonic()
        else:
            print("Unable to retrieve data at {}".format(url))

    gfx.update_time()
    time.sleep(300)  # wait 5 minutes before updating anything again
```

### Weather Graphics Library

Next is to go over the graphics file:

https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/EInk_Bonnet_Weather_Station/weather_graphics.py

First start by importing any libraries that will be used. The notable library this time is  **PIL,**  the Python Imaging library, which is used to handle all the font rendering.

```python
from datetime import datetime
import json
from PIL import Image, ImageDraw, ImageFont
from adafruit_epd.epd import Adafruit_EPD
```

Next, to set up the fonts. If you would like to change them, you can do so here. Each font is a combination of the font file and the font size in points.

```python
small_font = ImageFont.truetype(
    "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 16
)
medium_font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 20)
large_font = ImageFont.truetype(
    "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 24
)
icon_font = ImageFont.truetype("./meteocons.ttf", 48)
```

The next step is to create an icon map, which will map the specified [OpenWeather icon code](https://openweathermap.org/weather-conditions) to the font character that the [meteocons font](http://www.alessioatzeni.com/meteocons/) uses. If you wanted to change the icons, this would be the place to make changes.

```python
# Map the OpenWeatherMap icon code to the appropriate font character
# See http://www.alessioatzeni.com/meteocons/ for icons
ICON_MAP = {
    "01d": "B",
    "01n": "C",
    "02d": "H",
    "02n": "I",
    "03d": "N",
    "03n": "N",
    "04d": "Y",
    "04n": "Y",
    "09d": "Q",
    "09n": "Q",
    "10d": "R",
    "10n": "R",
    "11d": "Z",
    "11n": "Z",
    "13d": "W",
    "13n": "W",
    "50d": "J",
    "50n": "K",
}
```

Next to define a couple of colors to make the code more readable:

```python
# RGB Colors
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
```

The actual `Weather_Graphics` class:

```python
class Weather_Graphics:
```

The first function in the Weather Graphics is code to initialize any variables that will store default values including setting the fonts that were set up earlier.

```python
def __init__(self, display, *, am_pm=True, celsius=True):
    self.am_pm = am_pm
    self.celsius = celsius

    self.small_font = small_font
    self.medium_font = medium_font
    self.large_font = large_font

    self.display = display

    self._weather_icon = None
    self._city_name = None
    self._main_text = None
    self._temperature = None
    self._description = None
    self._time_text = None
```

The `display_weather` function formats the data that is passed in into something more readable to humans. As it does, it prints the value to the console to make debugging easier. Once everything is set, it calls the function to update the time.

```python
def display_weather(self, weather):
    weather = json.loads(weather.decode("utf-8"))

    # set the icon/background
    self._weather_icon = ICON_MAP[weather["weather"][0]["icon"]]

    city_name = weather["name"] + ", " + weather["sys"]["country"]
    print(city_name)
    self._city_name = city_name

    main = weather["weather"][0]["main"]
    print(main)
    self._main_text = main

    temperature = weather["main"]["temp"] - 273.15  # its...in kelvin
    print(temperature)
    if self.celsius:
        self._temperature = "%d °C" % temperature
    else:
        self._temperature = "%d °F" % ((temperature * 9 / 5) + 32)

    description = weather["weather"][0]["description"]
    description = description[0].upper() + description[1:]
    print(description)
    self._description = description
    # "thunderstorm with heavy drizzle"

    self.update_time()
```

The `update_time` function is pretty short. It just retrieves the time from the Linux operating system using the **datetime** library, then it formats and sets the value to one of the class variables. Once that is done, it calls the `update_display` function.

```python
def update_time(self):
    now = datetime.now()
    self._time_text = now.strftime("%I:%M %p").lstrip("0").replace(" 0", " ")
    self.update_display()
```

The last function in the library is the `update_display` function, which is used to take the values of each of the class variables and draw them to a canvas. PIL's `Image.new()` function is used to create a canvas the size of the display and then the `draw.text()` function is used to draw the text to the canvas in various locations. Once all the text is drawn, the canvas is passed into the EPD library with the `self.display.image()` function and then the display is refreshed with the `self.display.display()` function.

```python
def update_display(self):
    self.display.fill(Adafruit_EPD.WHITE)
    image = Image.new("RGB", (self.display.width, self.display.height), color=WHITE)
    draw = ImageDraw.Draw(image)

    # Draw the Icon
    (font_width, font_height) = icon_font.getsize(self._weather_icon)
    draw.text(
        (
            self.display.width // 2 - font_width // 2,
            self.display.height // 2 - font_height // 2 - 5,
        ),
        self._weather_icon,
        font=icon_font,
        fill=BLACK,
    )

    # Draw the city
    draw.text(
        (5, 5), self._city_name, font=self.medium_font, fill=BLACK,
    )

    # Draw the time
    (font_width, font_height) = medium_font.getsize(self._time_text)
    draw.text(
        (5, font_height * 2 - 5),
        self._time_text,
        font=self.medium_font,
        fill=BLACK,
    )

    # Draw the main text
    (font_width, font_height) = large_font.getsize(self._main_text)
    draw.text(
        (5, self.display.height - font_height * 2),
        self._main_text,
        font=self.large_font,
        fill=BLACK,
    )

    # Draw the description
    (font_width, font_height) = small_font.getsize(self._description)
    draw.text(
        (5, self.display.height - font_height - 5),
        self._description,
        font=self.small_font,
        fill=BLACK,
    )

    # Draw the temperature
    (font_width, font_height) = large_font.getsize(self._temperature)
    draw.text(
        (
            self.display.width - font_width - 5,
            self.display.height - font_height * 2,
        ),
        self._temperature,
        font=self.large_font,
        fill=BLACK,
    )

    self.display.image(image)
    self.display.display()
```


## Featured Products

### Adafruit 2.13" Monochrome E-Ink Bonnet for Raspberry Pi

[Adafruit 2.13" Monochrome E-Ink Bonnet for Raspberry Pi](https://www.adafruit.com/product/4687)
Easy e-paper finally comes to Raspberry Pi, with this bonnet that's designed to make it a breeze to add a 2.13" 250x122 crisp monochromic eInk display. Chances are you've seen one of those new-fangled 'e-readers' like the Kindle or Nook. They have gigantic electronic...

Out of Stock
[Buy Now](https://www.adafruit.com/product/4687)
[Related Guides to the Product](https://learn.adafruit.com/products/4687/guides)
### Raspberry Pi 4 Model B

[Raspberry Pi 4 Model B](https://www.adafruit.com/product/4297)
The Raspberry Pi 4 Model B is the newest Raspberry Pi computer made, and the Pi Foundation knows you can always make a good thing _better_! And what could make the Pi 4 better than the 3? How about a _faster_ processor, USB 3.0 ports, and updated Gigabit Ethernet chip with...

Out of Stock
[Buy Now](https://www.adafruit.com/product/4297)
[Related Guides to the Product](https://learn.adafruit.com/products/4297/guides)
### Adafruit 2.13" Monochrome eInk / ePaper Display with SRAM

[Adafruit 2.13" Monochrome eInk / ePaper Display with SRAM](https://www.adafruit.com/product/4197)
Easy e-paper finally comes to microcontrollers, with this breakout that's designed to make it a breeze to add a monochromatic eInk display. Chances are you've seen one of those new-fangled 'e-readers' like the Kindle or Nook. They have gigantic electronic paper 'static'...

In Stock
[Buy Now](https://www.adafruit.com/product/4197)
[Related Guides to the Product](https://learn.adafruit.com/products/4197/guides)
### Tactile Button switch (6mm) x 20 pack

[Tactile Button switch (6mm) x 20 pack](https://www.adafruit.com/product/367)
Little clicky switches are standard input "buttons" on electronic projects. These work best in a PCB but [can be used on a solderless breadboard as shown in this tutorial](https://learn.adafruit.com/adafruit-arduino-lesson-6-digital-inputs?view=all). The pins are normally...

In Stock
[Buy Now](https://www.adafruit.com/product/367)
[Related Guides to the Product](https://learn.adafruit.com/products/367/guides)
### Through-Hole Resistors - 100K ohm 5% 1/4W - Pack of 25

[Through-Hole Resistors - 100K ohm 5% 1/4W - Pack of 25](https://www.adafruit.com/product/2787)
ΩMG! You're not going to be able to resist these handy resistor packs! Well, axially, they do all of the resisting for you!

This is a **25 Pack of 100K Ω Resistors.** More specifically, they are **carbon film** , through-hole...

In Stock
[Buy Now](https://www.adafruit.com/product/2787)
[Related Guides to the Product](https://learn.adafruit.com/products/2787/guides)
### Full Sized Premium Breadboard - 830 Tie Points

[Full Sized Premium Breadboard - 830 Tie Points](https://www.adafruit.com/product/239)
This is a 'full-size' premium quality breadboard, 830 tie points. Good for small and medium projects. It's 2.2" x 7" (5.5 cm x 17 cm) with a standard double-strip in the middle and two power rails on both sides. You can pull the power rails off easily to make the...

In Stock
[Buy Now](https://www.adafruit.com/product/239)
[Related Guides to the Product](https://learn.adafruit.com/products/239/guides)
### Premium Male/Male Jumper Wires - 40 x 6" (150mm)

[Premium Male/Male Jumper Wires - 40 x 6" (150mm)](https://www.adafruit.com/product/758)
Handy for making wire harnesses or jumpering between headers on PCB's. These premium jumper wires are 6" (150mm) long and come in a 'strip' of 40 (4 pieces of each of ten rainbow colors). They have 0.1" male header contacts on either end and fit cleanly next to each other...

Out of Stock
[Buy Now](https://www.adafruit.com/product/758)
[Related Guides to the Product](https://learn.adafruit.com/products/758/guides)
### Stacking Header - 2x20 Extra Tall Header

[Stacking Header - 2x20 Extra Tall Header](https://www.adafruit.com/product/1979)
Stack multiple plates, breakouts etc onto your Raspberry Pi Model B+ with this custom-made extra-tall and extra-long 2x20 female header. The female header part has extra spaces to make it 23mm tall: when placed on your Pi, a PCB will clear the Ethernet and USB jacks. The stacky pin part...

In Stock
[Buy Now](https://www.adafruit.com/product/1979)
[Related Guides to the Product](https://learn.adafruit.com/products/1979/guides)

## Related Guides

- [Adafruit 2.13" Monochrome E-Ink Bonnet for Raspberry Pi](https://learn.adafruit.com/2-13-in-e-ink-bonnet.md)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings.md)
- [Raspberry Pi E-Ink Event Calendar using Python](https://learn.adafruit.com/raspberry-pi-e-ink-desk-calendar-using-python.md)
- [Adafruit eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-eink-display-breakouts.md)
- [Severance Portable Macrodata Refinement Terminal](https://learn.adafruit.com/portable-macrodata-refinement-terminal.md)
- [MagTag Showerthoughts and Quotes](https://learn.adafruit.com/magtag-showerthoughts.md)
- [Google Graveyard with Adafruit MagTag](https://learn.adafruit.com/google-graveyard-with-adafruit-magtag.md)
- [Python Edge Speech Recognition with Voice2JSON](https://learn.adafruit.com/edge-speech-recognition-with-voice2json.md)
- [ePaper Maze Maker](https://learn.adafruit.com/epaper-maze-maker.md)
- [Character LCD with Raspberry Pi or BeagleBone Black](https://learn.adafruit.com/character-lcd-with-raspberry-pi-or-beaglebone-black.md)
- [MagTag James Webb Telescope Status](https://learn.adafruit.com/magtag-james-webb-telescope-status.md)
- [Interpreting Environmental Sensor Data With Local "Edge" LLMs](https://learn.adafruit.com/interpreting-environmental-sensor-data-with-llms.md)
- [Raspberry Pi YouTube Boombox](https://learn.adafruit.com/youtube-radio.md)
- [Raspberry Pi Camera Timelapse Case](https://learn.adafruit.com/pi-timelapse.md)
- [Adafruit PCF8591 Basic 4 x ADC + DAC Breakout](https://learn.adafruit.com/adafruit-pcf8591-adc-dac.md)