If you've been diggin' our monochome OLEDs but need something bigger, this display will delight you. These displays are 2.3" diagonal, and very readable due to the high contrast of an OLED display. This display is made of 128x32 individual blue OLED pixels, each one is turned on or off by the controller chip. Because the display makes its own light, no backlight is required. This reduces the power required to run the OLED and is why the display has such high contrast; we really like this graphic display for its crispness!

The driver chip, SSD1305 can communicate in three ways: 8-bit, I2C or SPI. Personally we think SPI is the way to go, only 4 or 5 wires are required and its very fast. The OLED itself requires a 3.3V power supply and 3.3V logic levels for communication. We include a breadboard-friendly level shifter that can convert 3V or 5V down to 3V, so it can be used with 5V-logic devices like Arduino.

The power requirements depend a little on how much of the display is lit but on average the display uses about 50mA from the 3.3V supply. Built into the OLED driver is a simple boost converter that turns 3.3V into a high voltage drive for the OLEDs. The boost converter which may make a squeaking/buzzing noise, which you can minimize by adding hot-glue or foam tape around the inductor but may not be completely removable.

Each order comes with one assembled OLED module with a nice bezel and 4 mounting holes. The display is 3V logic & power so we include a HC4050 level shifter. We also toss in a 220uF capacitor, as we noticed an Arduino may need a little more capacitance on the 3.3V power supply for this big display! This display does not come with header attached but we do toss in a stick of header you can solder on. Also, the display may come in 8-bit mode. You can change modes from 8-bit to SPI or I2C with a little soldering, check out the tutorial for how to do so.

Getting started is easy! We have a detailed tutorial and example code in the form of an Arduino library for text and graphics. You'll need a microcontroller with more than 512 bytes of RAM since the display must be buffered. The library can print text, bitmaps, pixels, rectangles, circles and lines. It uses 512 bytes of RAM since it needs to buffer the entire display but its very fast! The code is simple to adapt to any other microcontroller.

This is a fancy upgrade to standard 16x2 LCDs, instead of just having blue and white, or red and black, this LCD has full color RGB characters on a dark/black background! That means you can change the character display colors to anything you want - red, green, blue, pink, white, purple yellow, teal, salmon, chartreuse. This LCD looks strikingly good in personWe had these custom made to our specification so that you can use them in existing LCD projects and they'll still work - just that only the red LED will be used (so it will appear red-on-black). The extra two pins (17 and 18) are for the green and blue LEDs. The LCD has resistors on board already so that you can drive it with 5V logic and the current draw will be ~20mA per LED. There's a single LED backlight for the entire display, the image above showing 3 colors at once is a composite!Comes with a single 16x2 RGB backlight LCD, 10K necessary contrast potentiometer and strip of header. Our tutorials and diagrams will have you up and running in no time! For more information, check out our detailed step-by-step tutorial for both Arduino & CircuitPython

This new Adafruit Pi Plate makes it easy to use an RGB 16x2 Character LCD. We really like the RGB Character LCDs we stock in the shop. (For RGB we have RGB negative and RGB positive.) Unfortunately, these LCDs do require quite a few digital pins, 6 to control the LCD and then another 3 to control the RGB backlight for a total of 9 pins. That's nearly all the GPIO available on a Pi!With this in mind, we wanted to make it easier for people to get these LCD into their projects so we devised a Pi plate that lets you control a 16x2 Character LCD, up to 3 backlight pins AND 5 keypad pins using only the two I2C pins on the R-Pi! The best part is you don't really lose those two pins either, since you can stick i2c-based sensors, RTCs, etc and have them share the I2C bus. This is a super slick way to add a display without all the wiring hassle.New, we've updated this Pi plate so the buttons on on the right side, which makes it a little more mechanically stableThis pi plate is perfect for when you want to build a stand-alone project with its own user interface. The 4 directional buttons plus select button allows basic control without having to attach a bulky computer.The plate is designed for both Revision 1 and Revision 2 Raspberry Pi's. It uses the I2C (SDA/SCL) pins. We have a special xtra-tall 26-pin header so the plate sits above the USB and Ethernet jacks. For Pi Model B+ and Pi 2, the resistors sit right above the new set of USB ports. To keep them from shorting against the metal, a piece of electrical tape must be placed onto the USB ports.This product comes as a kit! Included is a high quality PCB and all the components (buttons, header etc). A 16x2 Character RGB positive LCD is included! Assembly is easy, even if you've never soldered before and the kit can be completed in 30 minutes. Check the product tutorial page for assembly instructions before purchasingWe also have some handy Python code to help you easily talk to the LCD and buttons You can also easily query the 5 keypad buttons to get input through the library, so you get extra buttons without using any more pins. The buttons are automatically de-bounced inside the library.At this time, the code and plate can control the RGB backlight of our character LCDs by turning each LED on or off. This means you can display the following colors: Red, Yellow, Green, Teal, Blue, Violet, White and all off. There is no support for PWM control of the backlight at this time, so if you need to have more granular control of the RGB backlight to display a larger range of colors, this plate can't do that (the I2C expander does not have PWM output).Product page with tutorials, documentation and assembly information

If you've been diggin' our monochome OLEDs but need something bigger, this display will delight you. These displays are 2.7" diagonal, and very readable due to the high contrast of an OLED display. This display is made of 128x64 individual white OLED pixels, each one is turned on or off by the controller chip. Because the display makes its own light, no backlight is required. This reduces the power required to run the OLED and is why the display has such high contrast; we really like this graphic display for its crispness!

The driver chip, SSD1325 can communicate in two ways: 8-bit or SPI. Personally we think SPI is the way to go, only 4 or 5 wires are required. The OLED itself requires a 3.3V power supply and 3.3V logic levels for communication. We include a breadboard-friendly level shifter that can convert 3V or 5V down to 3V, so it can be used with 5V-logic devices like Arduino.

The power requirements depend a little on how much of the display is lit but on average the display uses about 50-150mA from the 3.3V supply. Built into the OLED driver is a simple boost converter that turns 3.3V into a high voltage drive for the OLEDs. The boost converter which may make a squeaking/buzzing noise, which you can minimize by adding hot-glue or foam tape around the inductor but may not be completely removable.

Each order comes with one assembled OLED module with a nice bezel and 4 mounting holes. The display is 3V logic & power so we include a 74HC4050 (or compatible) level shifter. We also toss in a 220uF capacitor, as we noticed an Arduino may need a little more capacitance on the 3.3V power supply for this big display! This display does not come with header attached but we do toss in a stick of header you can solder on. Also, the display may come in 8-bit mode. You can change modes from 8-bit to SPI with a little soldering, check out the tutorial for how to do so.

Getting started is easy! We have a detailed tutorial and example code in the form of an Arduino library for text and graphics. You'll need a microcontroller with more than 1K of RAM since the display must be buffered. The library can print text, bitmaps, pixels, rectangles, circles and lines. It uses 1K of RAM since it needs to buffer the entire display but its very fast! The code is simple to adapt to any other microcontroller.

A stylish and super slim (7mm) 3x16 character display with 3 RGB backlights for flair from our friends at Pimoroni. On the PCB there's a handy 9-segment bar-graph for indicators and a 4-direction joystick with a push button for navigation. The Pimoroni Display-O-Tron 3000 also comes with full Pimoroni Python support so you can get it up and running easily.

The DoT3k works with model B+, model B, model A+, and model A Raspberry Pi's.

Add some jazz & pizzazz to your project with a color touchscreen LCD. This TFT display is 2.4" diagonal with a bright (4 white-LED) backlight and it's colorful! 240x320 pixels with individual RGB pixel control, this has way more resolution than a black and white 128x64 display.

As a bonus, this display has a resistive touchscreen attached to it already, so you can detect finger presses anywhere on the screen.

If you need a larger touchscreen, check out the 2.8" diagonal or 3.5" diagonal TFT breakouts. For a smaller display, see our non-touch 2.2" or 1.8" or 1.44" diagonal TFTs

This display has a controller built into it with RAM buffering, so that almost no work is done by the microcontroller. The display can be used in two modes: 8-bit or SPI. For 8-bit mode, you'll need 8 digital data lines and 4 or 5 digital control lines to read and write to the display (12 lines total). SPI mode requires only 5 pins total (SPI data in, data out, clock, select, and d/c) but is slower than 8-bit mode.

In addition, 4 pins are required for the touch screen (2 digital, 2 analog) or you can purchase and use our resistive touchscreen controller (not included) to use I2C or SPI.

Of course, we wouldn't just leave you with a datasheet and a "good luck!". For 8-bit interface fans we've written a full open source graphics library that can draw pixels, lines, rectangles, circles, text, and more. For SPI users, we have a library as well, its separate from the 8-bit library since both versions are heavily optimized. For resistive touch, we also have a touch screen library that detects x, y and z (pressure) and example code to demonstrate all of it. Check out our tutorial for wiring diagrams, schematics, and a walkthough on this display.

Make a scrolling sign, or a small video display with this 8x8 gridded bi-color LED matrix. Only 1.2" on a side, it is quite visible but not so large it wont plug into a breadboard! 128 LEDs are contained in the plastic body, 64 red 320mcd and 64 green, in an 8x8 matrix. Every grid has two LEDs inside so you can have it display red, green, yellow or with fast multiplexing any color in between. This display is bright, beautiful and funky with nice diffused square lenses for a striking look. There are 24 pins on the side, 12 on each, with 0.1" spacing so you can easily plug it into a breadboard with one row on each side for wiring it up.

Since the display is in a grid, you'll need to 1:8 multiplex control it. We suggest either using two 74HC595s and TPIC6B595 (using the 74HC' to control the 16 anodes at once and then using the TPIC' to drive one cathode at a time) or using two MAX7219 which will do the multiplexing work for you.

The Arduino playground has a nice set of tutorials introducing the MAX7219 and 8x8 LED matrices

What's better than a single LED? Lots of LEDs! A fun way to make a small colorful display is to use a 1.2" Bi-color 8x8 LED Matrix. Matrices like these are 'multiplexed' - so to control all the 128 LEDs you need 24 pins. That's a lot of pins, and there are driver chips like the MAX7219 that can help control a matrix for you but there's a lot of wiring to set up and they take up a ton of space. Here at Adafruit we feel your pain! After all, wouldn't it be awesome if you could control a matrix without tons of wiring? That's where these adorable LED matrix backpacks come in. We have them in three flavors - a mini 8x8, 1.2" Bi-color 8x8 and a 4-digit 0.56" 7-segment. They work perfectly with the matrices we stock in the Adafruit shop and make adding a bright little display trivial. It's called a Bicolor LED, but you can have 3 colors total by turning on the red and green LEDs, which creates yellow-orange. That's 3 colors for the price of 2!The matrices use a driver chip that does all the heavy lifting for you: They have a built in clock so they multiplex the display. They use constant-current drivers for ultra-bright, consistent color, 1/16 step display dimming, all via a simple I2C interface. The backpacks come with address-selection jumpers so you can connect up to four mini 8x8's or eight 7-segments/bicolor (or a combination, such as four mini 8x8's and two 7-segments and two bicolor, etc) on a single I2C bus.The product kit comes with:

A fully tested and assembled LED backpack

1.2" Bi-color 8x8 LED Matrix

4-pin header

A bit of soldering is required to attach the matrix onto the backpack but its very easy to do and only takes about 5 minutes.Of course, in classic Adafruit fashion, we also have a detailed tutorial showing you how to solder, wire and control the display. We even wrote a very nice library for the backpacks so you can get running in under half an hour, displaying images on the matrix or numbers on the 7-segment. If you've been eyeing matrix displays but hesitated because of the complexity, his is the solution you've been looking for!

Design a clock, timer or counter into your next project using our pretty 4-digit seven-segment display. These bright crisp displays are good for adding numeric output. Besides the four 7-segments, there are decimal points on each digit and an extra wire for colon-dots in the center (good for time-based projects).These are 18mcd bright. You can drive these with less current to get the same brightness to save power, or crank them up to 20mA and have them at their brightest.These displays are multiplexed, common-cathode. What that means it that you can use a 74HC595 or just 8 microcontroller pins if you can spare them to control the 8 anodes (7-seg + decimal) at about ~15mA each, and then connect NPN transistors or a TPIC6B595 to the cathodes to sink the 8*15mA = ~160mA maximum per digit.

We strongly recommend getting our backpack version, which comes with an LED driver on the back. This version is just the raw display, and requires a lot more work to get running!These come in a bright red color, we also have many other sizes and colors!

Design a clock, timer or counter into your next project using our pretty 4-digit seven-segment display. These bright crisp displays are good for adding numeric output. Besides the four 7-segments, there are decimal points on each digit and an extra wire for colon-dots in the center (good for time-based projects).These are 15mcd bright. You can drive these with less current to get the same brightness to save power, or crank them up to 20mA and have them at their brightest.These displays are multiplexed, common-cathode. What that means it that you can use a 74HC595 or just 8 microcontroller pins if you can spare them to control the 8 anodes (7-seg + decimal) at about ~15mA each, and then connect NPN transistors or a TPIC6B595 to the cathodes to sink the 8*15mA = ~120mA maximum per digit.

We strongly recommend getting our backpack version, which comes with an LED driver on the back. This version is just the raw display, and requires a lot more work to get running!

These come in a bright blue color, we also have many other sizes and colors!

Design a clock, timer or counter into your next project using our pretty 4-digit seven-segment display. These bright crisp displays are good for adding numeric output. Besides the four 7-segments, there are decimal points on each digit and an extra wire for colon-dots in the center (good for time-based projects).These are 30mcd bright. You can drive these with less current to get the same brightness to save power, or crank them up to 20mA and have them at their brightest.These displays are multiplexed, common-cathode. What that means it that you can use a 74HC595 or just 8 microcontroller pins if you can spare them to control the 8 anodes (7-seg + decimal) at about ~15mA each, and then connect NPN transistors or a TPIC6B595 to the cathodes to sink the 8*15mA = ~120mA maximum per digit.

We strongly recommend getting our backpack version, which comes with an LED driver on the back. This version is just the raw display, and requires a lot more work to get running!

These come in a bright white color, we also have many other sizes and colors!

4-digit 7-segment displays are really neat little devices, it’s a shame that they can be so cumbersome to control. Well we’ve solved that problem by making them a little bit “smarter.” The SparkFun 7-Segment Serial Display combines a classic 4-digit 7-segment display and an ATMega328 microcontroller allowing you to control every segment individually using only a few serial lines.

The Serial 7-Segment Display can be controlled in one of three ways: Serial TTL communication, SPI serial communication or I2C serial. You can even program it for stand-alone operation since the ATMega328 comes pre-loaded with the Arduino bootloader! There is also an FTDI header on board and we’ve provided a hardware profile for the Arduino IDE to make it even easier to program.

We’ve made some layout changes to this design as well which will make it easier to incorporate these into your project. We’ve moved the power and I2C pins to the sides of the board such that you can chain them together in order to display longer strings of digits. We’ve also added mounting holes to the boards so you can mount them on standoffs (no more hot glue!)

Features

4 digit white alpha-numeric display with TTL, SPI or I2C Serial Interface

Display numbers, most letters, and a few special characters

Individual control of decimal points, apostrophe, and colon

Selectable baud rate

Selectable brightness

Baud rate and brightness values retained in non-volatile memory

Individual segment control for each digit

41mm x 23mm (1.6in x 0.9in)

4-digit 7-segment displays are really neat little devices, it’s a shame that they can be so cumbersome to control. Well we’ve solved that problem by making them a little bit “smarter.” The SparkFun 7-Segment Serial Display combines a classic 4-digit 7-segment display and an ATMega328 microcontroller allowing you to control every segment individually using only a few serial lines.

The Serial 7-Segment Display can be controlled in one of three ways: Serial TTL communication, SPI serial communication or I2C serial. You can even program it for stand-alone operation since the ATMega328 comes pre-loaded with the Arduino bootloader! There is also an FTDI header on board and we’ve provided a hardware profile for the Arduino IDE to make it even easier to program.

We’ve made some layout changes to this design as well which will make it easier to incorporate these into your project. We’ve moved the power and I2C pins to the sides of the board such that you can chain them together in order to display longer strings of digits. We’ve also added mounting holes to the boards so you can mount them on standoffs (no more hot glue!)

Replaces:COM-09765

Features

4 digit blue alpha-numeric display with TTL, SPI or I2C Serial Interface

Display numbers, most letters, and a few special characters

Individual control of decimal points, apostrophe, and colon

Selectable baud rate

Selectable brightness

Baud rate and brightness values retained in non-volatile memory

Individual segment control for each digit

41mm x 23mm (1.6in x 0.9in)

4-digit 7-segment displays are really neat little devices, it’s a shame that they can be so cumbersome to control. Well we’ve solved that problem by making them a little bit “smarter.” The SparkFun 7-Segment Serial Display combines a classic 4-digit 7-segment display and an ATMega328 microcontroller allowing you to control every segment individually using only a few serial lines.

The Serial 7-Segment Display can be controlled in one of three ways: Serial TTL communication, SPI serial communication or I2C serial. You can even program it for stand-alone operation since the ATMega328 comes pre-loaded with the Arduino bootloader! There is also an FTDI header on board and we’ve provided a hardware profile for the Arduino IDE to make it even easier to program.

We’ve made some layout changes to this design as well which will make it easier to incorporate these into your project. We’ve moved the power and I2C pins to the sides of the board such that you can chain them together in order to display longer strings of digits. We’ve also added mounting holes to the boards so you can mount them on standoffs (no more hot glue!)

Replaces:COM-09766

Features

4 digit red alpha-numeric display with TTL, SPI or I2C Serial Interface

Display numbers, most letters, and a few special characters

Individual control of decimal points, apostrophe, and colon

Selectable baud rate

Selectable brightness

Baud rate and brightness values retained in non-volatile memory

Individual segment control for each digit

41mm x 23mm (1.6in x 0.9in)

This is not your basic 7-segment display. The Dual 7-Segment Display features two digits with an RGB LED in every single segment! You will now have a small 7-segment LED in your project with a full-color display!

The Dual 7-Segment Display is breadboard friendly and possesses a digit height of 0.56in (14.22mm). The red LEDs have a forward voltage of 2VDC, 2.85VDC for green, and 2.95VDC for blue, with a continuous forward current per segment of 10mA for the red LEDs and 5mA for the green and blue.

Your basic 7-segment LED. Common anode. Two decimal points, but only the one on the right is wired. Digit height is 0.6". Overall height is 1"

If you'd like a compact display, with buttons and a joystick - we've got what you're looking for. The Adafruit 128x64 OLED Bonnet for Raspberry Pi is the big sister to our mini PiOLED add-on. This version has 128x64 pixels (instead of 128x32) and a much larger screen besides. With the OLED display in the center, we had some space on either side so we added a 5-way joystick and two pushbuttons. Great for when you want to have a control interface for your project.

These displays are small, only about 1.3" diagonal, but very readable due to the high contrast of an OLED display. This screen is made of 128x64 individual white OLED pixels and because the display makes its own light, no backlight is required. This reduces the power required to run the OLED and is why the display has such high contrast; we really like this miniature display for its crispness!

Please note that this display is too small to act as a primary display for the Pi (e.g. it can't act like or display what would normally be on the HDMI screen). Instead, we recommend using pygame for drawing or writing text.

Using the display and controls in python is very easy, we have a library ready-to-go for the SSD1306 OLED chipset and the joystick/buttons are connected to GPIO pins on the Pi. Our example code allows you to draw images, text, whatever you like, using the Python imaging library. We also have example code for using the joystick/buttons/OLED together. Our tests showed 15 FPS update rates so you can do animations or simple video.

Comes completely pre-assembled and tested so you don't need to do anything but plug it in and install our Python code! Works with any Raspberry Pi computer, including the original Pi 1, B+, Pi 2, Pi 3 and Pi Zero.

Instructions, software, downloads and more in the Learning Guide!

Add some jazz & pizazz to your project with a color touchscreen LCD. This TFT display is big (2.8" diagonal) bright (4 white-LED backlight) and colorful! 240x320 pixels with individual RGB pixel control, this has way more resolution than a black and white 128x64 display. As a bonus, this display has a resistive touchscreen attached to it already, so you can detect finger presses anywhere on the screen. We also have a version of this display breakout with a capacitive touchscreen.

This display has a controller built into it with RAM buffering, so that almost no work is done by the microcontroller. The display can be used in two modes: 8-bit and SPI. For 8-bit mode, you'll need 8 digital data lines and 4 or 5 digital control lines to read and write to the display (12 lines total). SPI mode requires only 5 pins total (SPI data in, data out, clock, select, and d/c) but is slower than 8-bit mode. In addition, 4 pins are required for the touch screen (2 digital, 2 analog) or you can purchase and use our resistive touchscreen controller (not included) to use I2C or SPI

We wrapped up this display into an easy-to-use breakout board, with SPI connections on one end and 8-bit on the other. Both are 3-5V compliant with high-speed level shifters so you can use with any microcontroller. If you're going with SPI mode, you can also take advantage of the onboard MicroSD card socket to display images. (microSD card not included, but any will work)

Of course, we wouldn't just leave you with a datasheet and a "good luck!". For 8-bit interface fans we've written a full open source graphics library that can draw pixels, lines, rectangles, circles, text, and more. For SPI users, we have a library as well, its separate from the 8-bit library since both versions are heavily optimized. We also have a touch screen library that detects x, y and z (pressure) and example code to demonstrate all of it.

Follow our step by step guide for wiring, code and drawing. You'll be running in 15 minutes

If you are using an Arduino-shaped microcontroller, check out our TFT shield version of this same display, with SPI control and a touch screen controller as well

The 1.3" 168x144 SHARP Memory LCD display is a cross between an eInk (e-paper) display and an LCD. It has the ultra-low power usage of eInk and the fast-refresh rates of an LCD. This model has a gray background, and pixels show up as black-on-gray for a nice e-reader type display. It does not have a backlight, but it is daylight readable. For dark/night reading you may need to illuminate the LCD area with external LEDs.The bare display is 3V powered and 3V logic, so we placed it on a fully assembled & tested breakout board with a 3V regulator and level shifting circuitry. Now you can use it safely with 3 or 5V power and logic. The bare display slots into a ZIF socket on board and we use a piece of double-sided tape to adhere it onto one side. There are four mounting holes so you can easily attach it to a box.The display is 'write only' which means that it only needs 3 pins to send data. However, the downside of a write-only display is that the entire 168x144 bits (3 KB) must be buffered by the microcontroller driver. That means you cannot use this with an ATmega328 (e.g. Arduino UNO) or ATmega32u4 (Feather 32u4, etc). You must use a high-RAM chip such as ATSAMD21 (Feather M0), Teensy 3, ESP8266, ESP32, etc. On those chips, this display works great and looks wonderful.

Check our our detailed guide for wiring diagrams, schematics, libraries, code, Fritzing objects, etc!

Looking for an unashamedly old school LED matrix display board? Lookie here! The Pimoroni Micro Dot pHAT is made up of six red LED matrices, each 5x7 pixels (for an effective display area of 30x7) plus a decimal point, using the beautiful little Lite-On LTP-305 matrices.

Perfect for building a retro scrolling message display, a tiny 30-band spectrum analyzer, or a retro clock. Far out!

As with the other pHATs, it works with all of the 40-pin Raspberry Pi variants - 3/2/B+/A+/Zero - but using it with the Pi Zero makes for a super-tiny package.

Features:

3x onboard IS31FL3730 LED matrix driver chips

Drives up to 6 x LTP-305 red LED matrices

Up to 30x7 pixels (5x7 per matrix plus a decimal point)

Kit includes:

Assembled Micro Dot pHAT PCB

2x20 0.1" female GPIO header

6 Red LTP-305 LED modules

Micro Dot pHAT also works well with other pHATs and HATs. You could use it in combination with pHAT DAC to display the audio spectrum, or with Enviro pHAT to display its temperature, pressure and light readings. Give it a try!

Note: These pHAT boards require you to solder on the headers and LTP-305 modules (through-hole components). Works with any 40-pin Raspberry Pi variant.

The Intel® Edison is an ultra small computing platform that will change the way you look at embedded electronics. Each Edison is packed with a huge amount of tech goodies into a tiny package while still providing the same robust strength of your go-to single board computer. Powered by the Intel® Atom™ SoC dual-core CPU and including an integrated WiFi, Bluetooth LE, and a 70-pin connector to attach a veritable slew of shield-like “Blocks” which can be stacked on top of each other. It’s no wonder how this little guy is lowering the barrier of entry on the world of electronics!

Equip your Edison with a graphic display using the Edison OLED Block! Simply snap this board onto your Edison to gain access to a 0.66", 64x48 pixel monochrome OLED. To add some control over your Edison and the OLED, this board also includes a small joystick and a pair of push-buttons which can be used them to create a game, file navigator, or more!

If you are looking to add a little more stability to your Intel® Edison stack, check out this Hardware Pack. It will provide you with increased mechanical strength for stacking Blocks on your Edison!

A Feather board without ambition is a Feather board without FeatherWings! This is the FeatherWing OLED: it adds a 128x32 monochrome OLED plus 3 user buttons to any Feather main board. Using our Feather Stacking Headers or Feather Female Headers you can connect a FeatherWing on top of your Feather board and let the board take flight!

These displays are small, only about 1" diagonal, but very readable due to the high contrast of an OLED display. This screen is made of 128x32 individual white OLED pixels and because the display makes its own light, no backlight is required. This reduces the power required to run the OLED and is why the display has such high contrast; we really like this miniature display for its crispness! We also toss on a reset button and three mini tactile buttons called A B and C so you can add a mini user interface to your feather.

Tested working with all Feather boards. The OLED uses only the two I2C pins on the Feather, and you can pretty much stack it with any other FeatherWing, even ones that use I2C since that is a shared bus. To use, Check out our tutorial ! It has schematics, datasheets, files, and code examples.

Check out our range of Feather boards here.

One segment? No way dude! 7-Segments for life!

A Feather board without ambition is a Feather board without FeatherWings! This is the Adafruit 4-Digit 7-Segment LED Matrix Display FeatherWing! This 7-segment FeatherWing backpack makes it really easy to add a 4-digit numeric display with decimal points and even 'second colon dots' for making a clock.

This version does not come with an LED matrix. Its also available in combo packs of Blue, Green, Red, White, or Yellow which we recommend since you'll know you have a working LED matrix. Not guaranteed to work with any other 7-segment modules.

7-Segment Matrices like these are 'multiplexed' - so to control all the seven-segment LEDs you need 14 pins. That's a lot of pins, and there are driver chips like the MAX7219 that can control a matrix for you but there's a lot of wiring to set up and they take up a ton of space. Here at Adafruit we feel your pain! After all, wouldn't it be awesome if you could control a matrix without tons of wiring? That's where these LED Matrix FeatherWings come in!

The LEDs themselves do not connect to the Feather. Instead, a matrix driver chip (HT16K33) does the multiplexing for you. The Feather simply sends i2c commands to the chip to tell it what LEDs to light up and it is handled for you. This takes a lot of the work and pin-requirements off the Feather. Since it uses only I2C for control, it works with any Feather and can share the I2C pins for other sensors or displays.

The product kit comes with:

A fully tested and assembled Adafruit 4-Digit 7-Segment LED Matrix Display FeatherWing

Two 16-pin headers

A bit of soldering is required to attach the matrix onto the FeatherWing but its very easy to do and only takes about 5 minutes!  Note: Feather board and seven-segment display are not included, but we have lots available in the shop.

Check out our detailed tutorial for pinouts, assembly, Arduino and CircuitPython usage, and more!

Display, elegantly, 012345678 or 9! Gaze, hypnotized, at ABCDEFGHIJKLM - well it can display the whole alphabet. You get the point.

A Feather board without ambition is a Feather board without FeatherWings! This is the Adafruit 0.56" 4-Digit 14-Segment Display FeatherWing! This 14-segment FeatherWing backpack makes it really easy to add a bright alphanumeric display that shows letters and numbers in a beautiful hue. It's super bright and designed for viewing from distances up to 23 feet (7 meters) away.

Works with any and all Feathers!

14-Segment Matrices like these are 'multiplexed' - so to control all the fourteen-segment LEDs you need 18 pins. That's a lot of pins, and there are driver chips like the MAX7219 that can control a matrix for you but there's a lot of wiring to set up and they take up a ton of space. Wouldn't it be awesome if you could control a matrix without tons of wiring? That's where these Alphanumeric LED Matrix FeatherWings come in, they make it really easy to add a 4-digit alphanumeric display with decimal points.

The LEDs themselves do not connect to the Feather. Instead, a matrix driver chip (HT16K33) does the multiplexing for you. The Feather simply sends i2c commands to the chip to tell it what LEDs to light up and it is handled for you. This takes a lot of the work and pin-requirements off the Feather. Since it uses only I2C for control, it works with any Feather and can share the I2C pins for other sensors or displays.

This product kit comes with:

A fully tested and assembled Adafruit 4-Digit 14-Segment Alphanumeric Display FeatherWing

Two sixteen pin headers

A bit of soldering is required to attach the matrix onto the FeatherWing but its very easy to do and only takes about 5 minutes!  Note: Feather board and 14-segment display are not included, but we have lots available in the shop.

Of course, in classic Adafruit fashion, we also have a detailed tutorial showing you how to solder, wire and control the display. We even wrote a very nice library for the backpacks in both Arduino & CircuitPython so you can get running in under half an hour, displaying letters or numbers on the 14-segment. If you've been eyeing matrix displays but hesitated because of the complexity, this is the solution you've been looking for.

Say hello to our 0.96" 160x80 Color TFT Display w/ MicroSD Card Breakout – we think it's T-F-Terrific! It's the size of your thumbnail, with glorious 160x80 pixel color. This very very small display is only 0.96" diagonal, packed with RGB pixels, for making very small high-density displays.

This lovely little display breakout is a great way to add a small, colorful and bright display to any project. Since the display uses 4-wire SPI to communicate and has its own pixel-addressable frame buffer, it can be used with every kind of microcontroller. Even a very small one with low memory and few pins available!

The 0.96" display has 160x80 color pixels. Unlike the low cost "Nokia 6110" and similar LCD displays, which are CSTN type and thus have poor color and slow refresh, this display is a true TFT! The TFT driver (ST7735R) can display full 16-bit color using our library code.

The breakout has the TFT display soldered on (it uses a delicate flex-circuit connector) as well as a ultra-low-dropout 3.3V regulator and a 3/5V level shifter so you can use it with 3.3V or 5V power and logic. We also had a little space so we placed a microSD card holder so you can easily load full color bitmaps from a FAT16/FAT32 formatted microSD card. The microSD card is not included, but you can pick one up here.

Of course, we wouldn't just leave you with a datasheet and a "good luck!" - we've written a full open source graphics library that can draw pixels, lines, rectangles, circles, text and bitmaps as well as example code and a wiring tutorial. The code is written for Arduino IDE but can be easily ported to your favorite microcontroller!

This is the latest evolution of our serial LCD. Included on a single board is a 16x2 LCD and an embedded circuit based around a PIC 16F88. The on-board PIC takes a TTL serial input and prints the characters it receives onto the LCD. The installed firmware also allows for a number of special commands so you can clear the screen, adjust the backlight brightness, turn the display on/off, and more.

Communication with SerLCD requires 5V TTL serial at a default baud rate of 9600bps (8-N-1). You can adjust the baud to any standard rate between 2400 and 38400bps. The power (VDD), ground (GND) and RX pins are all broken out to both a 0.1" pitch header as well as a 3-pin JST connector.

SerLCD has the ability to dim the backlight to conserve power if needed. There is also a potentiometer on the back of the display to adjust the contrast.

Features

Embedded PIC 16F88 utilizes onboard UART for greater communication accuracy

Adjustable baud rates of 2400, 4800, 9600 (default), 14400, 19200 and 38400

Operational Backspace

Greater processing speed at 10MHz

Incoming buffer stores up to 80 characters

Backlight transistor can handle up to 1A

Pulse width modulation of backlight allows direct control of backlight brightness and current consumption

All surface mount design allows a backpack that is half the size of the original

Faster boot-up time

Boot-up display can be turned on/off via firmware

User definable splash screen* PCB: 103x36mm

LCD: 71.4x26.4mm

The Nokia 5110 is a basic graphic LCD screen for lots of applications. It was originally intended to be used as a cell phone screen. This one is mounted on an easy to solder PCB.

It uses the PCD8544 controller, which is the same used in the Nokia 3310 LCD. The PCD8544 is a low power CMOS LCD controller/driver, designed to drive a graphic display of 48 rows and 84 columns. All necessary functions for the display are provided in a single chip, including on-chip generation of LCD supply and bias voltages, resulting in a minimum of external components and low power consumption. The PCD8544 interfaces to microcontrollers through a serial bus interface.

Note: There may be small blemishes on these screens as they are surplus.

Note: Your screen may or may not have a diode on the PCB. It does not affect performance and will vary depending on our shipment.

Features

45x45mm

NOTE: This is pinned out different to the one from Sparkfun

Nokia 5110 LCD Module, Arduino Compatible

You will Need: ( NOT Included in this Listing ! ) Set of Two 1K Resistors ( For Safe Operation ) Set of Four 10K Resistors ( For Safe Operation )

Pin Connections

1. RST--------- reset.

2. CE------------chip selection.

3. DC-----------data/commands choice.

4. DIN-----------serial data line.

5. CLK------------serial Clock Speed.

6. VCC----------Power, 3.3V (Positive).

7. LIGHT--------- backlight control terminal.

8. GND-----------power negative.

Specification:

Power supply voltage: 2.7V- 3.3V

Backlight Power Supply Voltage: 3.3V MAX

43.6mm x 43.1mm(width X height)

84 x 84 dot matrix LCD,can show 4 lines of characters, 12 Characters Per Line

Feature:

Uses Serial Peripheral Interface (SPI) to communicate with the microcontroller, only 8 signal lines including power and GND. Support different types of MCU (MicroController Unit) , such as Arduino, PICAXE, ARM, Raspberry PI etc. Transfer rate up to 4Mbps,can full speed write display data without waiting time.

LCD controller/driver chip has been bound to LCD chip so the overall footprint of the LCD Module is Kept as small as possible.

Has TWO Rows where header pins can be soldered for greater flexibility of use!

Low power supply, the working current in normal situation is lower than 200¦ÌA,and has power-down mode.

The MicroView is the first chip-sized Arduino compatible module that lets you see what your Arduino is thinking using a built-in OLED display. With the on-board 64x48 pixel OLED, you can use the MicroView to display sensor data, emails, pin status, and more. It also fits nicely into a breadboard to make prototyping easy. The MicroView also has a full-featured Arduino library to make programming the module easy.

In the heart of MicroView there is ATMEL’s ATmega328P, 5V & 3.3V LDO and a 64x48 pixel OLED display, together with other passive components that allow the MicroView to operate without any external components other than a power supply. Additionally, the MicroView is 100% code compatible with Arduino Uno (ATmega328P version), meaning the code that runs on an Arduino Uno will also be able to run on the MicroView if the IO pins used in the code are externally exposed on the MicroView.

Note: The MicroView programmer is sold separately. Check the recommended products below. Also, unlike the Kickstarter campaign, this does not come with the breadboard and USB cable. You only get the bare module.

Get Started with the SparkFun MicroView Guide

Features

64x48 Pixel OLED Display

ATmega328P

5V Operational Voltage

VIN Range: 3.3V - 16V

12 Digital I/O Pins (3 PWM)

6 Analog Inputs

Breadboard Friendly DIP Package

32KB Flash Memory

Arduino IDE 1.0+ Compatible

The SparkFun Micro OLED Breakout Board breaks out a small monochrome, blue-on-black OLED. It’s “micro”, but it still packs a punch – the OLED display is crisp, and you can fit a deceivingly large amount of graphics on there. This breakout is perfect for adding graphics to your next Arduino project, displaying diagnostic information without resorting to serial output, and teaching a little game theory while creating a fun, Arduino-based video game. Most important of all, though, is the Micro OLED is easy to control over either an SPI or I2C interface.

You may be asking yourself, “Why does this board look so familiar?” Yes, this is essentially a MicroView without the Arduino portion. We understand that sometimes you just need a breakout, an open door for you to explore the possibilities of a super small OLED screen. Speaking of, the screen on this breakout is only 64 pixels wide and 48 pixels tall, measuring 0.66" across.

In total, the Micro OLED Breakout provides access to 16 of the OLED’s pins. Fortunately, though, you’ll only need about half of them to make the display work. The top row of pins (GND-CS) breaks out everything you’d need to interface with the OLED over an SPI or I2C interface. The pins on the bottom (D7-vB) are mostly only used if you need to control the display over a parallel interface. This board operates at 3.3V with a current of 10mA (20mA max).

Get Started with the SparkFun Micro OLED Breakout Guide

Features

Operating Voltage: 3.3V

Screen Size: 64x48 pixels (0.66" Across)

Monochrome Blue-on-Black

SPI or I2C Interface

Because the Arduino (and Basic Stamp) are 5V devices, and most modern sensors, displays, flash cards and modes are 3.3V-only, many makers find that they need to perform level shifting/conversion to protect the 3.3V device from 5V.We do have some other handy level shifters in the shop, from the DIP 74LVC245 to the fancy bi-directional TXB0108. However, neither of these are happy to work with I2C, which uses a funky pull-up system to transfer data back and forth. This level shifter board combines the ease-of-use of the bi-directional TXB0108 with an I2C-compatible FET design following NXP's app note.This breakout has 4 BSS138 FETs with 10K pullups. It works down to 1.8V on the low side, and up to 10V on the high side. The 10K's do make the interface a little more sluggish than using a TXB0108 or 74LVC245 so we suggest checking those out if you need high-speed transfer.While we designed it for use with I2C, this works as well for  TTL Serial,  slow <2MHz SPI, and any other digital interface both uni-directional and bidirectional. Comes with a fully assembled, and tested PCB with 4 full bidirectional converter lines as well as 2 pieces of 6-pin header you can solder on to plug into a breadboard or perfboard.

Adding a character display to your project or computer has never been easier with the new Adafruit USB or TTL serial backpack! This custom-designed PCB can connect to the back of any 16x2 or 20x4 character LCD and does everything you could want: printing text, automatic scrolling, setting the backlight, adjusting contrast, making custom characters, turning on and off the cursor, etc. It can even handle our RGB backlight LCDs with full 8-bit PWM control of the backlight. That means you can change the background color to anything you want - red, green, blue, pink, white, purple yellow, teal, salmon, chartreuse, or just leave it off for a neutral background. On non-RGB backlights you'll be able to dim the backlight (it's on the same pin as the 'Red' LED)

Inside this backpack is an USB-capable AT90USB162 chip that listens for commands both a mini-B USB port and a TTL serial input wire. The USB interface shows up as a COM/serial port on Windows/Mac/Linux. The backpack will automatically select data from whichever input is being used. For the USB connection, it will work at any baud rate. For the TTL connection, the default baud rate is 9600 but you can send it a command to set the baud rate to 2400, 4800, 9600, 19200, 28800, or 57600 baud. (The baud rate is flashed on the LCD during powerup). Any customizations such as baud rate, backlight color, brightness, splash screen, etc. are stored permanently EEPROM.The command interface is compatible with the popular "Matrix Orbital" specifications so this backpack will work perfectly with computer applications or libraries that are expecting a "Matrix" LCD such as "LCD Smartie". We added a few extra commands for the RGB backlight and setting the LCD size. If you don't want to use the commands, you can just start sending ASCII to the LCD and it will magically appear as typed.

Does not include an LCD module! You'll need to pick out an LCD from the shop and solder it on the back.

Measure liquid/water flow for your solar, computer cooling, or gardening project using this handy basic flow meter. This sensor sit in line with your water line, and uses a pinwheel sensor to measure how much liquid has moved through it. The pinwheel has a little magnet attached, and there's a hall effect magnetic sensor on the other side of the plastic tube that can measure how many spins the pinwheel has made through the plastic wall. This method allows the sensor to stay safe and dry.The sensor comes with three wires: red (5-24VDC power), black (ground) and yellow (Hall effect pulse output). By counting the pulses from the output of the sensor, you can easily track fluid movement: each pulse is approximately 2.25 milliliters. Note this isn't a precision sensor, and the pulse rate does vary a bit depending on the flow rate, fluid pressure and sensor orientation. It will need careful calibration if better than 10% precision is required. However, its great for basic measurement tasks!We have an example Arduino sketch that can be used to quickly test the sensor - it will calculate the approximate quantity of fluid in liters and display on an LCD or the serial monitor.

This cable will let you swap out the stock 150mm long flex cable from a Raspberry Pi Camera (either 'classic' or 'NoIR' type) or Raspberry Pi Display for a different size. Works great, just carefully open the connector on the Pi and slip this one in.

This cable is 2 meters long. We have cables in a ton of sizes so you can have the perfect fit. Each order comes with one cable, Pi Camera not included (but we have those in the shop as well)

Please note, we did test this length cable with our Pi Model B/B+ and a Pi Camera and it worked great but 2 meters is really long for this kind of camera protocol, so if you have a very electrically noisy environment (inside a tesla coil?) you may have corrupted images.

These displays are small, only about 1" diagonal, but very readable due to the high contrast of an OLED display. This display is made of 128x32 individual white OLED pixels, each one is turned on or off by the controller chip. Because the display makes its own light, no backlight is required. This reduces the power required to run the OLED and is why the display has such high contrast; we really like this miniature display for its crispness!The driver chip SSD1306, communicates via SPI only. 4 or 5 pins are required to communicate with the chip in the OLED display.The OLED and driver require a 3.3V power supply and 3.3V logic levels for communication. To make it easier for our customers to use, we've added a 3.3v regulator and level shifter on board! This makes it compatible with any 5V microcontroller, such as the Arduino.The power requirements depend a little on how much of the display is lit but on average the display uses about 20mA from the 3.3V supply. Built into the OLED driver is a simple switch-cap charge pump that turns 3.3v-5v into a high voltage drive for the OLEDs, making it one of the easiest ways to get an OLED into your project!Of course, we wouldn't leave you with a datasheet and a "good luck": We have a detailed tutorial and example code in the form of an Arduino library for text and graphics. You'll need a microcontroller with more than 512 bytes of RAM since the display must be buffered.You can download our SSD1306 OLED display Arduino library from github which comes with example code. The library can print text, bitmaps, pixels, rectangles, circles and lines. It uses 512 bytes of RAM since it needs to buffer the entire display but its very fast! The code is simple to adapt to any other microcontroller.

These displays are small, only about 1.3" diagonal, but very readable due to the high contrast of an OLED display. This display is made of 128x64 individual white OLED pixels, each one is turned on or off by the controller chip. Because the display makes its own light, no backlight is required. This reduces the power required to run the OLED and is why the display has such high contrast; we really like this miniature display for its crispness!The driver chip, SSD1306 can communicate in two ways: I2C or SPI. The OLED itself require a 3.3V power supply and 3.3V logic levels for communication, but we include a 3.3V regulator and all pins are fully level shifted so you can use with 5V devices!The power requirements depend a little on how much of the display is lit but on average the display uses about 40mA from the 3.3V supply. Built into the OLED driver is a simple switch-cap charge pump that turns 3.3v-5v into a high voltage drive for the OLEDs.We have a detailed tutorial and example code in the form of an Arduino library for text and graphics. You'll need a microcontroller with more than 1K of RAM since the display must be buffered. The library can print text, bitmaps, pixels, rectangles, circles and lines. It uses 1K of RAM since it needs to buffer the entire display but its very fast! The code is simple to adapt to any other microcontroller.

The 7” Touchscreen Display for Raspberry Pi gives users the ability to create all-in-one, integrated projects such as tablets, infotainment systems and embedded projects!

The 800x480 display connects via an adapter board which handles power and signal conversion. Only two connections to the Pi are required; power from the Pi’s GPIO port and a ribbon cable that connects to the DSI port present on all Raspberry Pi’s.  Touchscreen drivers with support for 10-finger touch and an on-screen keyboard will be integrated into the latest Raspbian OS for full functionality without a physical keyboard or mouse.

Key features:

Truly Interactive - the latest software drivers will support a virtual ‘on screen’ keyboard, so there is no need to plug in a keyboard and mouse.

Make your own Internet of Things devices including a visual display. Simply connect your Raspberry Pi, develop a Python script to interact with the display, and you’re ready to create your own home automation devices with touch screen capability.

A range of educational software and programs available on the Raspberry Pi will be touch enabled, making learning and programming easier on the Raspberry Pi.

Kit contains:

7” Touchscreen Display

Adapter Board

DSI Ribbon cable

4 x stand-offs and screws (used to mount the adapter board and Raspberry Pi board to the back of the display)

4 x jumper wires (used to connect the power from the Adapter Board and the GPIO pins on the Pi so the 2Amp power is shared across both units)

Build instructions can be found here!

Note: Raspberry Pi and power supply are NOT included! Compatible with Raspberry Pi 3 Model B+, Raspberry Pi 3 Model B, Raspberry Pi 2, Model B+, and Model A+. The display will technically work with the Model A and Model B boards (connecting it to the DSI port on the Pi board), however, the mounting holes on the back of the display will only line up with the newer board designs (A+, B+, Pi 2, and Pi 3).