This allows a `localhost:4000`-style URL to be generated for local
testing, but still gives an absolute URL, which enhances compatibility
with RSS readers. A comment is added explaining the reason for the
absolute URL.
Closes#1374
.. and make sure all the times are at midnight GMT on the date the board
was added. Before this, the date was printed in the generating local time
zone; adding 12 hours often (but not always) made it be in the same GMT
day.
.. leading zeros are required for `frontmatter` to treat them as dates
rather than strings, apparently per the YAML specification.
This was done by script:
```py
import re
import datetime
import pathlib
import sys
import frontmatter
rx = re.compile(r'^(\s*)date_added:.*$', re.M)
for path_str in sys.argv[1:]:
print(path_str)
path = pathlib.Path(path_str)
post = frontmatter.load(path)
date_added = post.get("date_added", "")
if isinstance(date_added, datetime.date):
continue
if isinstance(date_added, str):
try:
date_added = datetime.datetime.strptime(date_added, "%Y-%m-%d")
except ValueError as exc:
print(f"Failed to parse date {date_added} in {path_str}: {exc}")
continue
date_added = date_added.date()
content = path.read_text("utf-8")
new_content = rx.sub(lambda m: f"{m.group(1)}date_added: {date_added}", content)
assert content != new_content
path.write_text(new_content, "utf-8")
```
This turns the search function into more of a 'fuzzy search': The search
is expected to be a series of space-separated terms, but the terms can
appear in any order, can be just part of a word (e.g., "uefr" would match
"bluefruit") and with other terms between them.
So for instance after this change both "tft feather" or "feather tft"
will show the Feather ESP32-S3 TFT PSRAM (as well as 3 other feather
boards)
Closes#1321
I guess the vendor documentation was corrected as this is the new version of that sensor on https://www.seeedstudio.com/Seeed-XIAO-BLE-Sense-nRF52840-p-5253.html
I was super confuse to read that this board could also `speak through the the microphone`. I guess that was lost in translation.
Accidently created a PR with the file in the wrong folder, moving it to the right one.
(My virtual machine crashed so doing it 'lazily' on github which doens't seem to have a move option for binary file so I'm deleting and reuploading it instead)
Fix the problem about not listing .bin or .uf2 file when clicking "Browse S3" button on own page of the board because of naming style of Deneyap boards.
Add Deneyap Development Boards' info and images.
List of Deneyap Development Boards
Deneyap Kart
Deneyap Mini
Deneyap Kart 1A
Deneyap Kart G
Deneyap Mini v2
Deneyap Kart 1A v2
.. it looks like the non-string value `3.0` was probably being
interpreted as `3` aka `3.x`?
Previously it looks like we built with 'ruby 3.1.3p185 (2022-11-24
revision 1a6b16756e) [x86_64-linux]' so I chose to pin at "3.1"
I try to manage expectation about this board and avoid short circuit or broken sensor.
1) I almost burned myself by mixing LOLIN I2C JST SH accessories and Adafruit QTPy, reverse way, I could have destroyed an Adafruit sensor by connecting it to Lolin S2 Pico.
2) The screen does not work as expected for a build-in screen, DISPLAY is not defined when you `import board`
I did hesitate between making a special section like "Caveats" or highlighting how it deviate from one can expect from a board running CircuitPython.
The previous link went to a version that wasn't being maintained and had a banner directing users to a different tool. Replace with a link to the version of ESP Web Flasher hosted on adafruit.github.io.
This means that the user can hit anywhere on the big target like
"Adafruit" instead of only being able to click the small checkbox. It
may also improve accessibility.
Additionally, the mouse cursor over the checkbox and its label is
changed to the "pointer" to indicate an action is available by clicking.
This board has a connector so that you can attach a display sold separatly.
Do we consider that a display?
From the documentation:
* "Besides, the onboard easy-to-connect GDI saves the trouble of wiring when using a screen."
* "Comes with expansion board, more convenient to make projects or use with a screen"
Should we consider a 7x17 LED matrix to be a display?
I believe only LCD or OLED display should be tagged as having a display.
However I added the Alligator Clip friendly as it looks like a Micro:bit.
3 board but two spelling:
* Two board use `manufacturer: "Switch Science, Inc"`
* One board use `manufacturer: "Switch Science, Inc."`
So I moved to the majority without that "."
There are two board by "microDev" but one is spelled "MicroDev", so I decided on a single case:
* manufacturer: "microDev"
Otherwise you have two entry in the Filter part.
Wrong infromation how to enter UF2 bootloader.
No propose changes button exist for "Install, Repair, or Update UF2 Bootloader" section on page
https://circuitpython.org/board/lolin_s2_mini/
We want to use remote CSS pulled from the main circuitpython.org site to enhance the usability of Web Work Flow without significantly impacting firmware size. This is an initial file so I can test and make sure it works as intended.
I am trying to make this more neutral and applicable to both the build-in antenna and the uFL connector version.
(I wish Adafruit could produce a picture that show both product next to each other for use on this page)
Have deleted duplicate text.
I have now realized the text has changed in the product page. On [https://www.adafruit.com/product/4884] the arduino support is mentioned, so it seems more a sync issue from the product page.
Updated that rp2040 based feather can use an Arduino core. Welcome feedback on how to phrase it.
A similar line should be included in all rp2040 based boards.
Thanks.
I'm guessing you meant "high speed SPI peripheral pins".
2 jokes come to mind:
1. Does "high speed puns" mean people don't have to think as much when I try to make a pun?
2. I think your finger had a vowel movement.
Putting a note on the S2 Mini page about an error on the silkscreen markings on v1.0 of the board.
GPIO12 and 13 are reversed from what they should be.
Link to the QT Py Haxpress build from the regular QT Py page.
I'm always clicking the wrong one, and have to go back to the main boards list, where
the sorting/order is unknown so the haxpress version isn't next to the regular one.
- selecting a language in one selects it in the other (if available)
- toss a couple of toLowerCase in there, since firefox uses lower case region codes, and the indonesian language string on the site is upper case
- includes the fix for the selecting languages by user preference, and testing the language string of the browser alone if the <language>-<region> string does not match
- does NOT compare <language> of the firmware port alone if it has a <language>-<region> because I am not sure that the languages are in order of priority (the default english implementation first for example), and I don't want users with "en-UK" to get offered "en-x-pirate" by default, it be bad matey ! Arrrrrrr
I have repeatedly been tripped up by wanting to enter a manufacturer
name in the text search area. While it is possible to open the
filter panel and select manufacturers, it is more convenient and intuitive
to simply enter this in the single text search box.
By concatenating several fields from the dataset (name, id, manufacturer,
and features), and then searching that it becomes possible to text-search
e.g., for "alligator" (board feature), "diary" (manufacturer) or
"metro_m4" (board id)
Per Phil. He stated that such documentation should be in markdown on circuitpython.org itself.
In this PR, no accompanying images are used. If images are desired, we will need to determine where to put them. Under /assets or under /doc or somewhere else.
A more detailed gude for adding a board to CircuitPython can be found in the
following Adafruit Learn guide: [How to add a New Board to the circuitpython.org website](https://learn.adafruit.com/how-to-add-a-new-board-to-the-circuitpython-org-website)
**To add a new board to the site:**
**To add a new board to the site:**
1. Duplicate `template.md` to `_board/<board id>.md`.
1. Duplicate `template.md` to `_board/<board id>.md`.
2. Edit `_board/<board id>.md` according to the template's instructions.
2. Edit `_board/<board id>.md` according to the template's instructions.
3. Provide 3 images. An original high-quality image. A smaller image (300 px width),
3. In your `_board/<board id>.md` you will specify a `board_image`. Create 3
and a larger image (700 px width) in each respective directory (assets/images/boards/{small large original})
versions of this file, in the following sizes and folder locations:
and process them in something like https://squoosh.app/ to reduce file size. If
you only have one image, place it in the 'original' folder.
|Size|File|Dimensions (px)|
3. Create a pull request with the file changes.
|--|--|--|
|Original|assets/images/orignal/{board_image}|900px+ width and 4:3 ratio width|
|||example: 900 x 675|
|Large|assets/images/large/{board_image}|800 x 600|
|Small|assets/images/small/{board_image}|300 x 225|
> For more information on preferred images or if you prefer or must use 13:10 see
> [Preparing the Images](https://learn.adafruit.com/how-to-add-a-new-board-to-the-circuitpython-org-website/preparing-the-images)
> in the Adafruit Learn guide
4. Create a pull request with the file changes.
**To test your changes locally:**
1. You need "ruby" and "ruby-bundler" installed locally. These instructions
were tested with ruby 2.5 and ruby-bundler 1.17.3 on a Debian Stretch system.
2. As needed, `git submodule update --init --recursive` to fetch the submodules
3. One time, run `bundle config set path 'vendor/bundle' && bundle install`
4. Run `bundle exec jekyll serve` to generate the site locally
5. Visit the displayed "server address"
6. After most local edits, the content will be updated. You will need to
A new chip means a new Feather, and the Raspberry Pi RP2040 is no exception. When we saw this chip we thought "this chip is going to be awesome when we give it the Feather Treatment" and so we did! This Feather features the **RP2040**, and all niceties you know and love about Feather.
## Technical details
* Measures 2.0" x 0.9" x 0.28" (50.8 mm x 22.8 mm x 7 mm) without headers soldered in
* Light as a (large?) feather - 5 grams
* RP2040 32-bit Cortex M0+ dual core running at ~125 MHz @ 3.3 V logic and power
* 264 KB RAM
* **8 MB SPI FLASH** chip for storing files and CircuitPython/MicroPython code storage. No EEPROM
* **21 GPIO pins with following capabilities:**
* **Four** 12 bit ADCs (one more than Pico)
* Two I2C, Two SPI and two UART peripherals, we label one for the 'main' interface in standard Feather locations
* 16 PWM outputs - for servos, LEDs, etc
* The 8 digital 'non-ADC/non-peripheral' GPIO are consecutive for maximum PIO compatibility
* **Built in 200 mA lipoly charger** with charging status indicator LED
* **Pin #13 red LED** for general purpose blinking
* **RGB NeoPixel** with power pin on GPIO so you can depower it for low power usages.
* On-board **STEMMA QT connector** that lets you quickly connect any Qwiic, STEMMA QT or Grove I2C devices with no soldering!
* **Both Reset button and Bootloader select button for quick restarts (no unplugging-replugging to relaunch code)**
* 3.3 V Power/enable pin
* [Optional SWD debug port can be soldered in for debug access](https://www.adafruit.com/product/752)
* 4 mounting holes
* 24 MHz crystal for perfect timing.
* 3.3 V regulator with 500 mA peak current output
* **USB-C connector** lets you access built-in ROM USB bootloader and serial port debugging
**Inside the RP2040 is a 'permanent ROM' USB UF2 bootloader.** What that means is when you want to program new firmware, you can hold down the BOOTSEL button while plugging it into USB (or pulling down the RUN/Reset pin to ground) and it will appear as a USB disk drive you can drag the firmware onto. Folks who have been using Adafruit products will find this very familiar - we use the technique on all our native-USB boards. Just note you don't double-click reset, instead hold down BOOTSEL during boot to enter the bootloader!
The RP2040 is a powerful chip, which has the clock speed of our M4 (SAMD51), and two cores that are equivalent to our M0 (SAMD1). Since it is an M0 chip, it does not have a floating point unit, or DSP hardware support - so if you're doing something with heavy floating-point math, it will be done in software and thus not as fast as an M4. For many other computational tasks, you'll get close-to-M4 speeds!
For peripherals, there are two I2C controllers, two SPI controllers, and two UARTs that are multiplexed across the GPIO - check the pinout for what pins can be set to which. There are 16 PWM channels, each pin has a channel it can be set to (ditto on the pinout).
You'll note there's no I2S peripheral, or SDIO, or camera, what's up with that? Well instead of having specific hardware support for serial-data-like peripherals like these, the RP2040 comes with the PIO state machine system which is a unique and powerful way to create custom hardware logic and data processing blocks that run on their own without taking up a CPU. For example, NeoPixels - often we bitbang the timing-specific protocol for these LEDs. For the RP2040, we instead use PIO object that reads in the data buffer and clocks out the right bitstream with perfect accuracy. Same with I2S audio in or out, LED matrix displays, 8-bit or SPI based TFTs, even VGA! In MicroPython and CircuitPython you can create PIO control commands to script the peripheral and load it in at runtime. There are 2 PIO peripherals with 4 state machines each.
**At the time of launch, there is no Arduino core support for this board. There is great [C/C++ support](https://github.com/raspberrypi/pico-sdk), an official [MicroPython port](https://github.com/raspberrypi/micropython), and a [CircuitPython port](/downloads)!** We of course [recommend CircuitPython because we think it's the easiest way to get started](https://learn.adafruit.com/welcome-to-circuitpython) and it has support with most of our drivers, displays, sensors, and more, supported out of the box so you can follow along with our CircuitPython projects and tutorials.
While the RP2040 has lots of onboard RAM (264 KB), it does not have built-in FLASH memory. Instead, that is provided by the external QSPI flash chip. **On this board there is 8 MB**, which is shared between the program it's running and any file storage used by MicroPython or CircuitPython. When using C/C++ you get the whole flash memory, if using Python you will have about 7 MB remaining for code, files, images, fonts, etc.
**RP2040 Chip features:**
* Dual ARM Cortex-M0+ @ 133 MHz
* 264 kB on-chip SRAM in six independent banks
* Support for up to 16MB of off-chip Flash memory via dedicated QSPI bus
* DMA controller
* Fully-connected AHB crossbar
* Interpolator and integer divider peripherals
* On-chip programmable LDO to generate core voltage
* 2 on-chip PLLs to generate USB and core clocks
* 30 GPIO pins, 4 of which can be used as analog inputs
* Peripherals
* 2 UARTs
* 2 SPI controllers
* 2 I2C controllers
* 16 PWM channels
* USB 1.1 controller and PHY, with host and device support
* 8 PIO state machines
Comes fully assembled and tested, with the UF2 USB bootloader. We also toss in some header, so you can solder it in and plug it into a solderless breadboard.
If you'd like quickly get started with CAN bus interfacing, with no soldering required, our **Adafruit RP2040 CAN Bus Feather** comes ready-to-rock with a microcontroller, CAN chipset and terminal blocks for instant gratification. [The controller used is the MCP26525 (aka a MCP2515 with built-in transciever), an extremely popular and well-supported chipset](https://www.microchip.com/en-us/product/MCP2515) that has drivers in Arduino and [CircuitPython](https://github.com/adafruit/Adafruit_CircuitPython_MCP2515) and only requires an SPI port and two pins for chip-select and IRQ. Use it to send and receive messages in either standard or extended format at up to 1 Mbps.
Feather is the development board specification from Adafruit, and like its namesake, it is thin, light, and lets you fly! We designed Feather to be a new standard for portable microcontroller cores. [We have other boards in the Feather family, check'em out here](https://www.adafruit.com/feather).
[CAN Bus is a small-scale networking standard](https://en.wikipedia.org/wiki/CAN_bus), originally designed for cars and, yes, busses, but is now used for many robotics or sensor networks that need better range and addressing than I2C and don't have the pins or computational ability to talk on Ethernet. CAN is 2 wire differential, which means it's good for long distances and noisy environments.
Messages are sent at about 1Mbps rate - you set the frequency for the bus and then all 'joiners' must match it, and have an address before the packet so that each node can listen in to messages just for it. New nodes can be attached easily because they just need to connect to the two data lines anywhere in the shared net. Each CAN device sends messages whenever it wants, and thanks to some clever data encoding, can detect if there's a message collision and retransmit later.
We've added a few nice extras to this Feather to make it useful in many common CAN scenarios:
- [**5V charge-pump voltage generator**](https://www.adafruit.com/product/3661), so even though you are running 3.3V on a Feather board, it will generate a nice clean 5V as required by the interal transceiver.
- **[3.5mm soldered terminal block](https://www.adafruit.com/product/725)** quick access to the High and Low data lines as well as a ground pin, without any soldering.
- **120-ohm termination resistor on board**, you can remove the termination easily by cutting the jumper marked TERM on the top of the board.
- **CAN control CS, Reset, Int, standby pins** connected internally so you can use any FeatherWing without pin conflicts.
At the Feather's heart is an RP2040 chip, clocked at 133 MHz and at 3.3V logic, the same one used in the [Raspberry Pi Pico](https://www.adafruit.com/product/4864). This chip has a whopping 8 MB of onboard QSPI FLASH and 264K of RAM! There's even room left over for a STEMMA QT connector for plug-and-play of I2C devices.
To make it easy to use for portable projects, we added a connector for any of our 3.7V Lithium polymer batteries and built-in battery charging. You don't need a battery, it will run just fine straight from the USB Type C connector. But, if you do have a battery, you can take it on the go, then plug in the USB to recharge. The Feather will automatically switch over to USB power when it's available.
**Here're some handy specs! You get:**
- Measures 2.0" x 0.9" x 0.28" (50.8mm x 22.8mm x 7mm) without headers soldered in
- Light as a (large?) feather - 6.3 grams
- RP2040 32-bit Cortex M0+ dual core running at ~133 MHz @ 3.3V logic and power
- 264 KB RAM
- **8 MB SPI FLASH** chip for storing files, images and CircuitPython/MicroPython code storage. No EEPROM
- Tons of GPIO! 21 x GPIO pins with following capabilities:
- **Four** 12-bit ADCs (one more than Pico)
- Two I2C, Two SPI, and two UART peripherals, we label one for the 'main' interface in standard Feather locations
- 16 x PWM outputs - for servos, LEDs, etc
- **Built-in 200mA+ lipoly charger** with charging status indicator LED
- **Pin #13 red LED** for general purpose blinking
- **RGB NeoPixel** for full-color indication.
- On-board **STEMMA QT connector** that lets you quickly connect any Qwiic, STEMMA QT or Grove I2C devices with no soldering!
- **Both Reset button and Bootloader select button for quick restarts** (no unplugging-replugging to relaunch code)
- **USB Type C connector** lets you access built-in ROM USB bootloader and serial port debugging
- 3.3V regulator with 500mA peak current output and power enable pin
- 4 mounting holes
- 12 MHz crystal for perfect timing.
- **Support circuitry for CAN Bus using SPI interface**
This is the Adafruit Feather RP2040 RFM9x. We call these RadioFruits, our take on a microcontroller with packet radio transceiver with built-in USB and battery charging. It's an Adafruit Feather RP2040 with a radio module cooked in! Great for making wireless networks that are more flexible than Bluetooth LE and without the high power requirements of WiFi.
Feather is the development board specification from Adafruit, and like its namesake, it is thin, light, and lets you fly! We designed Feather to be a new standard for portable microcontroller cores. We have other boards in the Feather family, check'em out here.
It's kinda like we took our RP2040 Feather and an RFM9x breakout board and glued them together. You get all the pins for use on the Feather, the LiPoly battery support, USB C power / data, onboard NeoPixel, 8MB of FLASH for storing code and files, and then with the 8 unused pins, we wired up all the DIO pins on the RFM module. There's even room left over for a STEMMA QT connector and a uFL connector for connecting larger antennas.
At the Feather's heart is an RP2040 chip, clocked at 133 MHz and at 3.3V logic, the same one used in the Raspberry Pi Pico. This chip has a whopping 8MB of onboard QSPI FLASH and 264K of RAM! This makes it great for making wireless sensor nodes that can send to each other without a lot of software configuration.
To make it easy to use for portable projects, we added a connector for any of our 3.7V Lithium polymer batteries and built-in battery charging. You don't need a battery, it will run just fine straight from the USB Type C connector. But, if you do have a battery, you can take it on the go, then plug in the USB to recharge. The Feather will automatically switch over to USB power when it's available.
## Technical Details
* Measures approximately 2.0" x 0.9" x 0.28" (50.8mm x 22.8mm x 7mm) without headers soldered in
* Light as a (large?) feather - approximately 6 grams
* RP2040 32-bit Cortex M0+ dual core running at ~133 MHz @ 3.3V logic and power
* 264 KB RAM
* 8 MB SPI FLASH chip for storing files and CircuitPython/MicroPython code storage. No EEPROM
* Tons of GPIO! 21 x GPIO pins with following capabilities:
* Four 12-bit ADCs (one more than Pico)
* Two I2C, Two SPI, and two UART peripherals, we label one for the 'main' interface in standard Feather locations
* 16 x PWM outputs - for servos, LEDs, etc
* Built-in 200mA+ lipoly charger with charging status indicator LED
* Pin #13 red LED for general purpose blinking
* RGB NeoPixel for full-color indication.
* On-board STEMMA QT connector that lets you quickly connect any Qwiic, STEMMA QT or Grove I2C devices with no soldering!
* Both Reset button and Bootloader select button for quick restarts (no unplugging-replugging to relaunch code)
* USB Type C connector lets you access built-in ROM USB bootloader and serial port debugging
* 3.3V Power/enable pin
* 4 mounting holes
* 12 MHz crystal for perfect timing.
* 3.3V regulator with 500mA peak current output
* SX127x LoRa® based module with SPI interface
* Packet radio with ready-to-go Arduino libraries
* Uses the license-free ISM bands (ITU "Europe" @ 433MHz and ITU "Americas" @ 900MHz)
* +5 to +20 dBm up to 100 mW Power Output Capability (power output selectable in software)
* ~300uA during full sleep, ~120mA peak during +20dBm transmit, ~40mA during active radio listening.
* Simple wire antenna can be soldered into a solder pad, there's also a uFL connector that can be used with uFL-to-SMA adapters for attaching bigger antennas.
This is the Adafruit Feather RP2040 RFM69. We call these RadioFruits, our take on a microcontroller with packet radio transceiver with built-in USB and battery charging. It's an Adafruit Feather RP2040 with a radio module cooked in! Great for making wireless networks that are more flexible than Bluetooth LE and without the high power requirements of WiFi.
Feather is the development board specification from Adafruit, and like its namesake, it is thin, light, and lets you fly! We designed Feather to be a new standard for portable microcontroller cores. We have other boards in the Feather family, check'em out here.
It's kinda like we took our RP2040 Feather and an RFM69 breakout board and glued them together. You get all the pins for use on the Feather, the LiPoly battery support, USB C power / data, onboard NeoPixel, 8MB of FLASH for storing code and files, and then with the 8 unused pins, we wired up all the DIO pins on the RFM module. There's even room left over for a STEMMA QT connector and a uFL connector for connecting larger antennas.
At the Feather's heart is an RP2040 chip, clocked at 133 MHz and at 3.3V logic, the same one used in the Raspberry Pi Pico. This chip has a whopping 8MB of onboard QSPI FLASH and 264K of RAM! This makes it great for making wireless sensor nodes that can send to each other without a lot of software configuration.
To make it easy to use for portable projects, we added a connector for any of our 3.7V Lithium polymer batteries and built-in battery charging. You don't need a battery, it will run just fine straight from the USB Type C connector. But, if you do have a battery, you can take it on the go, then plug in the USB to recharge. The Feather will automatically switch over to USB power when it's available.
## Technical Details
* Measures approximately 2.0" x 0.9" x 0.28" (50.8mm x 22.8mm x 7mm) without headers soldered in
* Light as a (large?) feather - approximately 6 grams
* RP2040 32-bit Cortex M0+ dual core running at ~133 MHz @ 3.3V logic and power
* 264 KB RAM
* 8 MB SPI FLASH chip for storing files and CircuitPython/MicroPython code storage. No EEPROM
* Tons of GPIO! 21 x GPIO pins with following capabilities:
* Four 12-bit ADCs (one more than Pico)
* Two I2C, Two SPI, and two UART peripherals, we label one for the 'main' interface in standard Feather locations
* 16 x PWM outputs - for servos, LEDs, etc
* Built-in 200mA+ lipoly charger with charging status indicator LED
* Pin #13 red LED for general purpose blinking
* RGB NeoPixel for full-color indication.
* On-board STEMMA QT connector that lets you quickly connect any Qwiic, STEMMA QT or Grove I2C devices with no soldering!
* Both Reset button and Bootloader select button for quick restarts (no unplugging-replugging to relaunch code)
* USB Type C connector lets you access built-in ROM USB bootloader and serial port debugging
* 3.3V Power/enable pin
* 4 mounting holes
* 12 MHz crystal for perfect timing.
* 3.3V regulator with 500mA peak current output
* SX1231 based module with SPI interface
* +13 to +20 dBm up to 100 mW Power Output Capability (power output selectable in software)
* 50mA (+13 dBm) to 150mA (+20dBm) current draw for transmissions, ~30mA during active radio listening.
* Range of approx. 500 meters, depending on obstructions, frequency, antenna and power output
* Create multipoint networks with individual node addresses
* Encrypted packet engine with AES-128
* Packet radio with ready-to-go Arduino & CircuitPython libraries
* Uses the license-free ISM band: "European ISM" @ 868MHz or "American ISM" @ 915MHz
* Simple wire antenna can be soldered into a solder pad, there's also a uFL connector that can be used with uFL-to-SMA adapters for attaching bigger antennas.
Easy e-paper and RP2040 finally come to your Feather with this Adafruit RP2040 Feather Think Ink that's designed to make it a breeze to add almost any common e-Ink/e-Paper display. Chances are you've seen one of those new-fangled 'e-readers' like the Kindle or Nook. They have gigantic electronic paper 'static' displays - that means the image stays on the display even when power is completely disconnected. The image is also high contrast and very daylight readable. It really does look just like printed paper!
We've liked these displays for a long time, and we've got Arduino/CircuitPython drivers for tons of the various display chipsets, so wouldn't an e-paper RP2040 Feather make a ton of sense? Luckily for us, just about every small-medium size EInk display made these days has a standard 24-pin connection. This Feather will add all the power supply support circuitry and level shifting so you can attach your favorite display - we've tested it with up to 5.6" sized 7-color ACeP displays.
Since all ePaper displays with the 24-pin interface require you to buffer the layers of data and write them all out at once over SPI, the RP2040 chip is an excellent driver. It has 264K of internal SRAM so even with the largest displays, there's plenty of memory to store all the image data plus run your own code. We also put the display on it's own SPI port so that the Feather's main SPI port can be used for other peripheral devices.
Feather is the development board specification from Adafruit, and like its namesake, it is thin, light, and lets you fly! We designed Feather to be a new standard for portable microcontroller cores. We have other boards in the Feather family, check'em out here.
At the Feather's heart is an RP2040 chip, clocked at 133 MHz and at 3.3V logic, the same one used in the Raspberry Pi Pico. This chip has a whopping MB of onboard QSPI FLASH and 264K of RAM! There's even room left over for a STEMMA QT connector for plug-and-play of I2C devices.
To make it easy to use for portable projects, we added a connector for any of our 3.7V Lithium polymer batteries and built-in battery charging. You don't need a battery, it will run just fine straight from the USB Type C connector. But, if you do have a battery, you can take it on the go, then plug in the USB to recharge. The Feather will automatically switch over to USB power when it's available. While the RP2040 is not designed for low power usage - you can get down to about 1.5mA of power draw in sleep mode.
Here're some handy specs! You get:
* Measures 2.0" x 0.9" x 0.28" (50.8mm x 22.8mm x 7mm) without headers soldered in
* Light as a (large?) feather - 6.3 grams
* RP2040 32-bit Cortex M0+ dual core running at ~133 MHz @ 3.3V logic and power
* 264 KB RAM
* 8 MB SPI FLASH chip for storing files, images and CircuitPython/MicroPython code storage. No EEPROM
* Tons of GPIO! 21 x GPIO pins with following capabilities:
* Four 12-bit ADCs (one more than Pico)
* Two I2C, Two SPI, and two UART peripherals, we label one for the 'main' interface in standard Feather locations
* 16 x PWM outputs - for servos, LEDs, etc
* Built-in 200mA+ lipoly charger with charging status indicator LED
* Pin #13 red LED for general purpose blinking
* RGB NeoPixel for full-color indication.
* On-board STEMMA QT connector that lets you quickly connect any Qwiic, STEMMA QT or Grove I2C devices with no soldering!
* Both Reset button and Bootloader select button for quick restarts (no unplugging-replugging to relaunch code)
* USB Type C connector lets you access built-in ROM USB bootloader and serial port debugging
* 3.3V regulator with 500mA peak current output and power enable pin
* 4 mounting holes
* 12 MHz crystal for perfect timing.
* Support circuitry for common 24-pin e-Paper/e-Ink displays. These tend to be 1.54" to 7" diagonal and designed for 'smart labels'. No soldering required, simply plug in the display to the FPC connector on the end and load up your code. Not for use with the larger resolution displays on e-Readers like Kindles. Those use a different interface!
A new chip means a new ItsyBitsy, and the Raspberry Pi RP2040 is no exception. When we saw this chip we thought "this chip is going to be awesome when we give it the ItsyBitsy teensy-weensy Treatment" and so we did! This Itsy' features the RP2040, and all niceties you know and love about the [ItsyBitsy family](https://www.adafruit.com/category/1008).
What's smaller than a Feather but larger than a Trinket? It's an Adafruit ItsyBitsy RP2040 featuring the Raspberry Pi RP2040! Small, powerful, with a ultra fast duel Cortex M0+ processor running at 125 MHz - this microcontroller board is perfect when you want something very compact, with lots of horsepower and a bunch of pins. This Itsy has sports car speed, but SUV roominess with 4 MB of FLASH and 264 KB of SRAM.
ItsyBitsy RP2040 is only 1.4" long by 0.7" wide, but has 6 power pins, 23 digital GPIO pins (4 of which can be analog in and 16 x PWM out). It's the same chip as the [Feather RP2040](https://www.adafruit.com/products/4884) and [Raspberry Pi Pico](https://www.adafruit.com/products/4883) *but really really small*. So it's great once you've finished up a prototype, and want to make the project much smaller. It even comes with 4MB of SPI Flash built in, for data logging, file storage, or CircuitPython/MicroPython code
## Technical details
- Same size and form-factor as the rest of the [ItsyBitsy family](https://www.adafruit.com/category/1008) and nearly-identical pinout
- Measures 1.4" x 0.7" x 0.2" (36 mm x 18 mm x 4 mm) without headers soldered in
- RP2040 32-bit Cortex M0+ dual core running at ~125 MHz @ 3.3V logic and power
- 264 KB RAM
- **4 MB SPI FLASH** chip for storing files and CircuitPython/MicroPython code storage. No EEPROM
- 23 GPIO pins with following capabilities:
- 4 12-bit ADCs (one more than Pico)
- 2 I2C, 2 SPI and 2 UART peripherals, we label one for the 'main' interface in standard ItsyBitsy locations
- 16 PWM outputs - for servos, LEDs, etc
- The 10 digital 'non-ADC/non-peripheral' GPIO are consecutive for maximum PIO compatibility
- **Pin #13 red LED** for general purpose blinking
- **RGB NeoPixel** with power pin on GPIO so you can depower it for low power usages.
- **Both Reset button and Bootloader select button for quick restarts (no unplugging-replugging to relaunch code)**
- 3.3 V regulator with 500mA peak current output
- 3.3 V Power/enable pin
- Power with either USB or external output (such as a battery) - it'll automatically switch over
- Broken-out SWD pins for debug access
- 24 MHz crystal for perfect timing.
- Special **Vhigh** output pin gives you the higher voltage from VBAT or VUSB, for driving NeoPixels, servos, and other 5V-logic devices. **Digital 5** level-shifted output for high-voltage logic level output.
- **USB Micro B connector** lets you access built-in ROM USB bootloader and serial port debugging
**Inside the RP2040 is a 'permanent ROM' USB UF2 bootloader**. What that means is when you want to program new firmware, you can hold down the BOOTSEL button while plugging it into USB (or pulling down the RUN/Reset pin to ground) and it will appear as a USB disk drive you can drag the firmware onto. Folks who have been using Adafruit products will find this very familiar - we use the technique on all our native-USB boards. Just note you don't double-click reset, instead hold down BOOTSEL during boot to enter the bootloader!
The RP2040 is a powerful chip, which has the clock speed of our M4 (SAMD51), and two cores that are equivalent to our M0 (SAMD21). Since it is an M0 chip, it does not have a floating point unit or DSP hardware support - so if you're doing something with heavy floating point math, it will be done in software and thus not as fast as an M4. For many other computational tasks, you'll get close-to-M4 speeds!
For peripherals, there are two I2C controllers, two SPI controllers, and two UARTs that are multiplexed across the GPIO - check the pinout for what pins can be set to which. There are 16 PWM channels, each pin has a channel it can be set to (ditto on the pinout).
You'll note there's no I2S peripheral, or SDIO, or camera, what's up with that? Well instead of having specific hardware support for serial-data-like peripherals like these, the RP2040 comes with the PIO state machine system which is a unique and powerful way to create *custom hardware logic and data processing blocks* that run on their own without taking up a CPU. For example, NeoPixels - often we bitbang the timing-specific protocol for these LEDs. For the RP2040, we instead use PIO object that reads in the data buffer and clocks out the right bitstream with perfect accuracy. [Same with I2S audio in or out, LED matrix displays, 8-bit or SPI based TFTs, even VGA](https://github.com/raspberrypi/pico-examples/tree/master/pio)! In MicroPython and CircuitPython you can create PIO control commands to script the peripheral and load it in at runtime. There are 2 PIO peripherals with 4 state machines each.
**At the time of launch, there is no Arduino core support for this board. There is great [C/C++ support](https://github.com/raspberrypi/pico-sdk), an official [MicroPython port](https://github.com/raspberrypi/micropython), and a [CircuitPython port](https://circuitpython.org/downloads)!** We of course [recommend CircuitPython because we think it's the easiest way to get started](https://learn.adafruit.com/welcome-to-circuitpython) and it has support with most of our drivers, displays, sensors, and more, supported out of the box so you can follow along with our CircuitPython projects and tutorials.
This Itsy comes with loose 0.1" headers you can solder in for breadboard use!
While the RP2040 has lots of onboard RAM (264KB), it does not have built-in FLASH memory. Instead, that is provided by the external QSPI flash chip. On this board there is 2MB, which is shared between the program it's running and any file storage used by MicroPython or CircuitPython. When using C/C++ you get the whole flash memory, if using Python you will have about 1 MB remaining for code, files, images, fonts, etc.
**RP2040 Chip features:**
- Dual ARM Cortex-M0+ @ 133MHz
- 264kB on-chip SRAM in six independent banks
- Support for up to 16MB of off-chip Flash memory via dedicated QSPI bus
- DMA controller
- Fully-connected AHB crossbar
- Interpolator and integer divider peripherals
- On-chip programmable LDO to generate core voltage
- 2 on-chip PLLs to generate USB and core clocks
- 30 GPIO pins, 4 of which can be used as analog inputs
- Peripherals
- 2 UARTs
- 2 SPI controllers
- 2 I2C controllers
- 16 PWM channels
- USB 1.1 controller and PHY, with host and device support
A wild Kee Boar appears! It’s a shiny **KB2040**! An Arduino Pro Micro-shaped board for Keebs with RP2040. (#keeblife 4 evah) A lot of folks like using Adafruit parts for their Keeb builds – but with the ItsyBitsy not being pin-compatible with the Pro Micro pinout, it really wasn't very easy without some sort of adapter plate.
Now we’re seeing lots of people use CircuitPython for keebs, which is awesome! So why not try our hands at spinning up a pro-micro-compatible RP2040 board? The RP2040 is plenty powerful, low-cost, and makes for an excellent keeb driver chip.
We mixed together what we liked most about the SparkFun Pro Micro RP2040 (**Qwiic / STEMMA QT I2C port on the end**, so good!) and Elite-C (**castellated pads & pins for D+ and D-**) and our existing RP2040 boards (**boot button can be used for user, 8MB QSPI flash, onboard NeoPixel, jumper for skipping the diode/fuse for high power RGB LEDs or USB hosting**). We even got it to all fit on a 2-layer PCB with 7/7 routing – just needed to make the smallest caps and resistors 0402.
With 20 GPIO available (18 on castellated pins, 2 on STEMMA QT port) you can easily make up to 100-keys matrices, or common 65% 5x15 layouts. [Use a plug-and-play QT cable to connect to the last two pins](https://www.adafruit.com/product/4209) without having to do any desoldering/rework.
## Technical details
- [Same size and form-factor as a Pro Micro breakout](https://www.sparkfun.com/products/12640) and nearly-identical pinout (this board has fewer analog pins, for example)
- Measures 1.3" x 0.7" without headers soldered in
- RP2040 32-bit Cortex M0+ dual core running at ~125 MHz @ 3.3 V logic and power. 264 KB RAM, No EEPROM. 12 MHz crystal for perfect timing.
- **8 MB SPI FLASH** chip for storing files and CircuitPython/MicroPython code storage.
- 20 GPIO pins with following capabilities:
- 18 GPIO on castellated/pin breakout pads. 2 GPIO on QT port that can be easily accessed for 5x15 keyboard layouts.
- 4 12 bit ADCs
- 2 I2C, 2 SPI and 2 UART peripherals, we label one of for the 'main' interface in standard Pro Micro locations
- 16 PWM outputs - for servos, LEDs, etc
- The 10 digital non-ADC GPIO are consecutive for maximum PIO compatibility
- **RGB NeoPixel** for colorful status indiction
- Classic **green power LED**
- Both Reset button and Bootloader select button for quick restarts. Bootloader button is also available as a generic GPIO input button.
- [STEMMA QT connector](https://learn.adafruit.com/introducing-adafruit-stemma-qt/what-is-stemma-qt) on the end is compatible with the [SparkFun Qwiic](https://www.sparkfun.com/qwiic) I2C connector, and can be used to plug and play I2C devices, or just as 2 extra GPIO pins.
- 3.3 V regulator with 500 mA peak current output
- **RAW** output, for powering NeoPixels or other 5 V devices. Jumper on bottom lets you skip over the 500 mA fuse, for up to 2 A from USB ports.
- **USB-C connector** lets you access built-in ROM USB bootloader and serial port debugging
- **Extra D- and D+ breakouts** for alternative USB connection options.
Strap yourself in, we're launching in T-minus 10 seconds...Destination? A new Class M planet called MACROPAD! M here, stands for Microcontroller because this 3x4 keyboard controller features the newest technology from the Raspberry Pi sector: say hello to the RP2040. It's speedy little microcontroller with lots of GPIO pins and a 64 times more RAM than the Apollo Guidance Computer. We added 8 MB of flash memory for plenty of storage.
Get ready to upgrade your desk's mission control station with a CircuitPython or Arduino powered Macropad - complete with 12 buttons, OLED display, speaker and rotary encoder. Customize it for your spacecraft to help guide you through the great reaches of the unknown. (Or just have it type out your favorite emojis.)
Each of the 12 sockets can accept a Cherry MX-compatible key switch. No soldering required, just snap it in! Use any key switch you like - but we recommend ones with slots that will allow the matching twelve NeoPixels underneath to shine through.
This space-ship is also fitted with a 128x64 monochome OLED for a crisp heads-up display that can be used in Arduino or CircuitPython to display keymaps, stats, computer performance, etc. There's also a rotary encoder with push-button soldered in. Twist and turn it or push to change volume or monitor brightness or scroll: whatever you like! A tiny speaker can give audio feedback or play fun bleepy tunes.
Want to add more hardware? No worries - [a STEMMA QT port on the side lets you connect any I2C add-on peripherals from the massive STEMMA QT / Qwiic family of plug in boards](https://www.adafruit.com/category/1018).
**Please note, the RP2040 chip does not currently have QMK support** - this macropad is designed to be programmed in Arduino or CircuitPython! If QMK eventually does add RP2040 as a supported chipset (no ETA and no plans that we know of), we'll update this page.
## Technical details
- **Raspberry Pi RP2040 Chip + 8MB Flash memory** - Dual core Cortex M0+ at ~130MHz with 264KB or RAM. Runs CircuitPython, Arduino or MicroPython with ease and lots of space for development code and files
- **USB C Connector for Power/Data** - of course this can act as an HID device but also can be MIDI, UART, etc.
- **3x4 Mechanical key switch sockets** - accepts any Cherry MX-compatible switches. Individually tied to GPIO pins (not matrix wired)
- **One NeoPixel RGB LED per switch**, on north side
- **Rotary encoder**, 20 detents per rotation, with push-switch on GPIO pin. Push switch is also used for entering bootloader mode when held down on power-up or reset.
- **128x64 SH1106 Monochrome OLED display** - On high speed hardware SPI port for quick updates
- **8mm Speaker/Buzzer** - With Class D amplifier and RC filter, can be used to make simple beeps and sounds effects.
- **STEMMA QT Connector** - Allows adding any I2C sensors/displays/devices with plug-and-play cables.
- **Reset button -** On the side, for quick restarting of code
- **Four M3 mounting bosses** - Make custom enclosures easily
It's half USB Key, half Adafruit QT Py, and a lotta RP2040*...*it's **Trinkey QT2040**, the circuit board with an RP2040 heart and Stemma QT legs. Folks are loving the [QT Py 2040](https://www.adafruit.com/product/4900) we made, but maybe you want something plug-and-play. So we thought, hey what if we made something like that plugs right into your computer's USB port? And this is what we came up with!
The PCB is designed to slip into any USB A port on a computer or laptop. There's an RP2040 microcontroller on board with just enough circuitry to keep it happy. There's an RGB NeoPixel, a reset and bootloader or user button and a STEMMA QT Port on the end. That's it!
With the body of the board being 1.0" x 0.7" and four mounting holes, you can attach just about any of our QT boards right on (some are a little larger so just check that has the holes in the same locations). [Use M2.5 sized standoffs and screws](https://www.adafruit.com/product/3658) to do so, you could use 2 diagonal at a minimum. Then use a [shorty QT cable](https://www.adafruit.com/product/4399) and you've got a custom sensor Trinkey for any sensor purpose.
The board comes with 8 MB of QSPI flash memory so you can put *all* of our CircuitPython drivers on the disk!
## Technical details
* Main body is same size/mounting holes as most of our Stemma QT boards (1.0" x 0.7" with M2.5 holes)
* USB Type A connector with extra-thick PCB to fit into a USB host port
* RP2040 32-bit Cortex M0+ dual-core running at ~125 MHz @ 3.3 V logic and power
* 264 KB RAM
* 8 MB SPI FLASH chip for storing files and CircuitPython/MicroPython code storage. No EEPROM
* Native USB supported by every OS - can be used as USB serial console, MIDI, Keyboard/Mouse HID, even a little disk drive for storing Python scripts.
* Built-in RGB NeoPixel LED
* STEMMA QT/Qwiic port for I2C connectivity
* 3.3 V regulator with 600 mA peak output
* 12 MHz crystal
* Both Reset button and Bootloader select buttons for quick restarts (no unplugging-replugging to relaunch code)
* Bootloader button can also be safely used in 'user' code
What a cutie pie! Or is it... a QT Py? This diminutive dev board comes with one of our new favorite chip, the RP2040. It's been made famous in the new [Raspberry Pi Pico](https://www.adafruit.com/pico) *and* our [Feather RP2040](http://www.adafruit.com/product/4884) and [ItsyBitsy RP2040](http://www.adafruit.com/product/4888), but what if we wanted something really *smol?*
A new chip means a new QT Py, and the Raspberry Pi RP2040 is no exception. When we saw this chip we thought "this chip is going to be awesome when we give it the cuuutie QT Py Treatment", and so we did! This QT Py features the RP2040, [and all niceties you know and love about the original QT Py](https://www.adafruit.com/category/4600)
The star of the QT Py is [our favorite connector - the STEMMA QT](http://adafruit.com/stemma), a chainable I2C port that can be used with [any of our STEMMA QT sensors and accessories](https://www.adafruit.com/category/620). Having this connector means you don't need to do any soldering to get started.
What can you pop into the QT port? How about [OLEDs](https://www.adafruit.com/?q=qt+oled&main_page=category&cPath=1005&sort=BestMatch)! [Inertial Measurment Units](https://www.adafruit.com/?q=qt+imu&main_page=category&cPath=1005&sort=BestMatch)! [Sensors a-plenty](https://www.adafruit.com/?q=qt+sensor&main_page=category&cPath=1005&sort=BestMatch). All plug-and-play thanks to the innovative chainable design: [SparkFun Qwiic](https://www.sparkfun.com/qwiic)-compatible [STEMMA QT](https://learn.adafruit.com/introducing-adafruit-stemma-qt) connectors for the I2C bus so you don't even need to solder. Just plug in a compatible cable and attach it to your MCU of choice, and you’re ready to load up some software and measure some light.
Use any [SparkFun Qwiic](http://www.sparkfun.com/qwiic) boards! [Seeed Grove I2C boards](https://www.adafruit.com/product/4528) will also work with this adapter cable.
**At the time of launch, there is no Arduino core support for the chip on this board. There is great [C/C++ support](https://github.com/raspberrypi/pico-sdk), an official [MicroPython port](https://github.com/raspberrypi/micropython), and a [CircuitPython port](https://circuitpython.org/downloads)!** We of course [recommend CircuitPython because we think it's the easiest way to get started](https://learn.adafruit.com/welcome-to-circuitpython) and it has support with most of our drivers, displays, sensors, and more, supported out of the box so you can follow along with our CircuitPython projects and tutorials.
Pinout and shape is [Seeed Xiao](https://wiki.seeedstudio.com/Seeeduino-XIAO/) compatible, with castellated pads so you can solder it to a PCB with a cut out to allow the bottom components some breathing room. In addition to the QT connector, we also added an **RGB NeoPixel** (with a controllable power pin to allow for ultra-low-power usage), **and both boot-mode and reset buttons** (great for restarting your program or entering the bootloader). This QT Py comes with loose 0.1" headers you can solder in for breadboard use.
While the RP2040 has lots of onboard RAM (264 KB), it does not have built-in FLASH memory. Instead, that is provided by the external QSPI flash chip. On this board there is 4MB, which is shared between the program it's running and any file storage used by MicroPython or CircuitPython. When using C/C++ you get the whole flash memory, if using Python you will have about 3 MB remaining for code, files, images, fonts, etc.
- Same size, form-factor, and pin-out as [our SAMD-based QT Py](https://www.adafruit.com/product/4600)
- **USB-C connector** - [If you have only Micro B cables, this adapter will come in handy](https://www.adafruit.com/product/4299)!
- **RP2040 32-bit Cortex M0+** dual-core running at ~125 MHz @ 3.3 V logic and power
- 264 KB RAM
- **8 MB SPI FLASH** chip for storing files and CircuitPython/MicroPython code storage. No EEPROM
- Native USB supported by every OS - can be used in Arduino or CircuitPython as USB serial console, MIDI, Keyboard/Mouse HID, even a little disk drive for storing Python scripts.
- Can be used with **Arduino IDE** or **CircuitPython**
- **Built-in RGB NeoPixel LED**
- 13 GPIO pins (11 breakout pads and two QT pads):
- **Four** 12 bit ADCs (one more than Pico)
- Two I2C ports (one on the QT connector, one on the breakout pads)
- SPI and UART peripherals, in standard QT Py locations,
- PWM outputs on every IO pin - for servos, LEDs, etc
- There are 6 GPIO in consecutive order for PIO compatibility
- 3.3 V regulator with [**600 mA peak output**](https://www.diodes.com/assets/Datasheets/AP2112.pdf)
- **Both Reset button and Bootloader select buttons** for quick restarts (no unplugging-replugging to relaunch code)
- **Really really small**
**Inside the RP2040 is a 'permanent ROM' USB UF2 bootloader**. What that means is when you want to program new firmware, you can hold down the BOOT button while plugging it into USB (or pulling down the RUN/Reset pin to ground) and it will appear as a USB disk drive you can drag the firmware onto. Folks who have been using Adafruit products will find this very familiar - we use the technique on all our native-USB boards. Just note you don't double-click reset, instead hold down BOOTSEL during boot to enter the bootloader!
The RP2040 is a powerful chip, which has the clock speed of our M4 (SAMD51), and two cores that are equivalent to our M0 (SAMD21). Since it is an M0 chip, it does not have a floating point unit or DSP hardware support - so if you're doing something with heavy floating point math, it will be done in software and thus not as fast as an M4. For many other computational tasks, you'll get close-to-M4 speeds!
For peripherals, there are two I2C controllers, two SPI controllers, and two UARTs that are multiplexed across the GPIO - check the pinout for what pins can be set to which. There are 16 PWM channels, each pin has a channel it can be set to (ditto on the pinout).
You'll note there's no I2S peripheral, or SDIO, or camera, what's up with that? Well, instead of having specific hardware support for serial-data-like peripherals like these, the RP2040 comes with the PIO state machine system which is a unique and powerful way to create *custom hardware logic and data processing blocks* that run on their own without taking up a CPU. For example, NeoPixels - often we bitbang the timing-specific protocol for these LEDs. For the RP2040, we instead use PIO object that reads in the data buffer and clocks out the right bitstream with perfect accuracy. [Same with I2S audio in or out, LED matrix displays, 8-bit or SPI based TFTs, even VGA](https://github.com/raspberrypi/pico-examples/tree/master/pio)! In MicroPython and CircuitPython you can create PIO control commands to script the peripheral and load it in at runtime. There are 2 PIO peripherals with 4 state machines each.
Gateways can be as varied as the devices they help connect, with each gateway needing different protocols, connection methodologies and energy requirements to bring together the myriad of distributed parts that make up the IoT whole. Gateways serve critical functions such as data filtering and security and up to application code. Whether an app on a mobile device, a demo board, or even a connected sensor, gateways are critical to the functioning of the IoT—and Avnet’s deep hardware experience help connect your solutions to the cloud smartly and with security in mind.
SmartEdge Industrial IoT Gateway, powered by Raspberry Pi, helps simplify and accelerate adoption of IIoT applications. The gateway provides versatile connectivity with data intelligence for a wide range of industrial 4.0 applications.
Empower analytics at the edge of your IoT network with the intelligent Dell Edge Gateway for richer business insights. An edge gateway connects varied wired and wireless devices and systems, aggregates and analyzes the input, and sends it on. Because the gateway sits close to your devices and sensors, it sends only meaningful data to the cloud or control center, saving you expensive bandwidth.
* Broadcom BCM2837 SoC, 64-bit, Quad-core ARM Cortex-A53 processor running up to 900 MHz + 1GB LPDDR2 SDRAM for data
* Robust program storage with 8GB eMMC Flash pre-programmed with a secure boot version of the Raspbian Linux OS
BPI-M2+ series run Android,Debian linux,Ubuntu linux, Raspberry Pi image and others image. Banana PI,it can easily run with the game it support 1080P high definition video output and 4K support, the GPIO compatible with Raspberry Pi B+ .
Banana Pi BPI-M2+ not support sata port, so you need use USB for hardisk
The Banana Pi M2 Zero is an ultra compact single board computer which measures only 60mm*30mm. Its external interfaces are the same as the Raspberry Pi Zero W, and it will fit almost all cases and accessories for the Zero W. It uses the quad-core Cortex A7 Allwinner H2+ processor, with 512MB RAM. It's ideal for light-weight systems and space-limited applications. Like other members of the Banana Pi family, it supports both Linux and Android operating systems.
Banana Pi BPI-M5 is the next generation single board computer from Banana Pi in 2020. It is powered by Amlogic S905X3 quad-core Cortex-A55 (2.0 XXGHz) processor.Onboard 4GB LPDDR4 memory and 16GB EMMC storage, and supports 4 USB 3.0 interface, a gigabit network port.
BeagleBone is an $89 MSRP, credit-card-sized Linux computer that connects to the Internet and runs software such as Android 4.0 and Ubuntu. With plenty of I/O and processing power for real-time analysis provided by an AM335x 720MHz ARM® processor, BeagleBone can be complemented with cape plug-in boards to augment functionality.
Built on the proven BeagleBoard.org® open source Linux approach, BeagleBone® AI fills the gap between small SBCs and more powerful industrial computers. Based on the Texas Instruments AM5729, developers have access to the powerful SoC with the ease of BeagleBone® Black header and mechanical compatibility. BeagleBone® AI makes it easy to explore how artificial intelligence (AI) can be used in everyday life via the TI C66x digital-signal-processor (DSP) cores and embedded-vision-engine (EVE) cores supported through an optimized TIDL machine learning OpenCL API with pre-installed tools. Focused on everyday automation in industrial, commercial and home applications.
- Processor: Sitara AM5729
- Dual Arm® Cortex®-A15 microprocessor subsystem
- 2 C66x floating-point VLIW DSPs
- 2.5MB of on-chip L3 RAM
- 2x dual Arm® Cortex®-M4 co-processors
- 4x Embedded Vision Engines (EVEs)
- 2x dual-core Programmable Real-Time Unit and Industrial Communication SubSystem (PRU-ICSS)
- 2D-graphics accelerator (BB2D) subsystem
- Dual-core PowerVR® SGX544™ 3D GPU
- IVA-HD subsystem (4K @ 15fps encode and decode support for H.264, 1080p60 for others)
- BeagleBone Black mechanical and header compatibility
- 1GB RAM and 16GB on-board eMMC flash with high-speed interface
- USB type-C for power and superspeed dual-role controller; and USB type-A host
- Gigabit Ethernet, 2.4/5GHz WiFi, and Bluetooth
- microHDMI
- Zero-download out-of-box software experience with Debian GNU/Linux
If you liked the BeagleBone Black Rev B, you will love the Rev C! The Rev C has a blistering 1GHz AM3358 processor and 512MB onboard DDR3 RAM, two 46-pin headers, micro HDMI for audio/video output, USB ports, 10/100 Ethernet and other I/O features. The Rev C is an ultra-powered embedded computer that can fit in a mint tin.
This model includes 4GB of eMMC built-in storage instead of the Rev B's 2GB. With the doubled storage and faster eMMC, the developers were able to make the Rev C's most significant change: shipping the BeagleBone Black with Debian Linux pre-loaded on the board's flash instead of Angstrom Linux. Debian Linux is a more user-friendly operating system than Angstrom and the switch to Debian is partly the result of consumer demand (especially from Adafruit users, thanks!)
Of course the BeagleBone Black Rev C is an open board so if you want to load it back up with Angstrom or other Linux-based distributions like Ubuntu or Android, you can.
The rev C comes with a mini-B cable for powering it up ASAP. No microSD card is included as the BBB has onboard flash storage - and no SD card loading is required to get started. Please note the PCB may say rev B, that's normal! The rev C has more memory which did not affect the PCB revision code.
- Processor: Sitara AM3358BZCZ100 1GHz, 2000 MIPS
- Graphics Engine: SGX530 3D, 20M Polygons/S
- SDRAM Memory: 512MB DDR3L 606MHZ
- Onboard Flash: 4GB, 8bit Embedded MMC
- PMIC: TPS65217C PMIC regulator and one additional LDO.
- Debug Support: Optional Onboard 20-pin CTI JTAG, Serial Header
- Power Source: miniUSB USB or DC Jack, 5VDC External Via Expansion Header
- PCB: 86.44mm x 54.54mm / 3.4” x 2.15” 6 layers
- 88.98mm x 54.54mm x 15.41mm / 3.5" x 2.15" x 0.6"
The element14 BeagleBone Black Industrial (BBONE-BLACK-IND-4G) is a low cost, high-expansion focused BeagleBoard using a low cost industrial temperature grade Sitara™ AM3358 ARM® Cortex™-A8 processor from Texas Instruments. BBONE-BLACK-IND-4G ships with the Debian Linux distribution preinstalled on the onboard FLASH, ready to start evaluation and development.
Replacing the 10/100 Ethernet port with onboard 802.11 b/g/n 2.4GHz WiFi and Bluetooth, the popular open source BeagleBone® Black computer now comes with built-in wireless networking capability. Leveraging a partnership with Octavo Systems and designed in CadSoft Eagle, BeagleBone® Black Wireless is the easiest to use and modify credit-card sized IoT Linux computer available.
- Processor: Octavo Systems OSD3358 1GHz ARM Cortex-A8
BeagleBone® Blue is an all-in-one Linux-based computer for robotics, integrating onto a single small (3.5" x 2.15") board the Octavo OSD3358 microprocessor together with wifi/bluetooth, IMU/barometer, power regulation and state-of-charge LEDs for a 2-cell LiPo, H-Bridges, and discrete connectors for 4 DC motors+encoders, 8 servos, and all of the commonly-needed buses for additional peripherals in embedded applications. Fully open source and actively supported by a strong community, the real-time performance, flexible networking, and rich set of robotics-oriented capabilities make building mobile robots with the Blue fast, streamlined, affordable, and fun.
- AM335x 1GHz ARM® Cortex-A8 processor
- 512MB DDR3 RAM
- 4GB 8-bit eMMC flash storage
- Integrated power management
- 2×32-bit 200-MHz programmable real-time units (PRUs)
- NEON floating-point accelerator
- ARM Cortex-M3
- USB2 client for power & communications, USB2 host
- Battery support: 2-cell LiPo with balancing, LED state-of-charge monitor
- Charger input: 9-18V
- Wireless: 802.11bgn, Bluetooth 4.1 and BLE
- Motor control: 8 6V servo out, 4 bidirectional DC motor out, 4 quadrature encoder in
Seeed Studio BeagleBone® Green Gateway is a low cost, open-source, community supported development platform for developers and hobbyists. It is a joint effort by BeagleBoard.org and Seeed Studio. It is based on the classical open-source hardware design of BeagleBone® Black and developed into this differentiated version. The Seeed Studio BeagleBone® Green Gateway includes two Grove connectors, making it easier to connect to the large family of Grove sensors. The on-board HDMI and Ethernet are removed to make room for these wireless features and Grove connectors.
The Seeed Studio BeagleBone® Green Gateway is a combination of Seeed Studio BeagleBone® Green and Seeed Studio BeagleBone® Green Wireless, equipped with both Ethernet and Wireless connectivity.
Boot Linux in less 10 seconds and get started on development in less than 5 minutes with just a single USB cable.
- Fully Compatible with BeagleBone® Black and Seeed Studio BeagleBone® Green
- Processor: AM3358 1GHz ARM® Cortex-A8
- 2×32-bit 200-MHz programmable real-time units (PRUs)
SeeedStudio BeagleBone Green Wireless (BBGW) is a joint effort by BeagleBoard.org and Seeed Studio. It is based on the open-source hardware design of BeagleBone Black and developed into this differentiated version. SeeedStudio BeagleBone Green Wireless has included a high-performance flexible WiFi/Bluetooth interface and two Grove connectors, making it easier to connect to the large family of Grove sensors. The on-board HDMI and Ethernet are removed to make room for these wireless features and Grove connectors.
- Processor: Sitara AM3358BZCZ100 1GHz, 2000 MIPS
- Graphics Engine: SGX530 3D, 20M Polygons/S
- SDRAM Memory: 512MB DDR3L 606MHZ
- Onboard Flash: 4GB, 8bit Embedded MMC
- PMIC: TPS65217C PMIC regulator and one additional LDO.
- Debug Support: Optional Onboard 20-pin CTI JTAG, Serial Header
- Power Source: miniUSB USB or DC Jack, 5VDC External Via Expansion Header
- PCB: 86.44mm x 54.54mm / 3.4” x 2.15” 6 layers
- 88.98mm x 54.54mm x 15.41mm / 3.5" x 2.15" x 0.6"
**The BeagleV™ - Starlight project has concluded and no units beyond the beta prototypes will be produced. This design was never sold as a product.**
[BeagleV Starlight](https://beagleboard.org/beaglev) is a Linux-capable RISC-V 64-bit dev board.
A [beta prototype version](https://wiki.seeedstudio.com/BeagleV-Getting-Started/#faq) was sent to a limited number of upstream developers for software enablement. This beta prototype used the StarFive JH7100 SoC.
The Binho Nova brings Multi-Protocol USB Host Adapters into the 21st Century. No more fumbling through development with cumbersome, clunky, out-dated adapters. Let your productivity soar to new heights!
With support for I2C, SPI, UART, 1-WIRE, SWI protocols all in one slim, robust package, it may even be the last adapter you’ll ever need...
With an intuitive user interface, our software is the quickest, simplest way to get up and running with your new Binho Nova. Whether you're working in a Windows, Linux, or macOS environment, our cross-platform solution has you covered. Alpha build available now with I2C, SPI, and IO functionality.
The NVIDIA Clara AGX™ developer kit delivers real-time AI and imaging for medical devices. By combining low-powered, NVIDIA Xavier SOC (system on a chip) and RTX GPUs with the NVIDIA Clara AGX SDK and the NVIDIA EGX stack, it’s easy to securely provision and remotely manage fleets of distributed medical instruments.
The NVIDIA Clara AGX™ developer kit is an embedded AI computer and software development framework for medical devices that need the ability to perform real-time AI and advanced image, video, and signal processing. Powered by ARM-based NVIDIA Xavier™ along with RTX GPUs and running the NVIDIA EGX software stack, Clara AGX securely manages and orchestrates AI application deployments to fleets of medical devices or edge nodes.
Piunora is a compact, easy-to-use development board for electronics prototyping with Linux. It has a familiar form factor, legible pin labels, and a design that’s well suited to space-constrained applications.
As a carrier board for the [Raspberry Pi Compute Module 4](https://www.raspberrypi.org/products/compute-module-4/?variant=raspberry-pi-cm4001000) (CM4), Piunora is essentially a tiny version of the Raspberry Pi 4 Single Board Computer (SBC) with added flexibility to accommodate custom form factors. CM4-based devices like Piunora are fully compatible with software that was written for the Raspberry Pi 4, as long as that software accounts for the hardware peripherals in use. There are also versions of the CM4 that include eMMC memory, which is more reliable than a traditional SD card.
It may be small, but Piunora is packed with powerful peripherals that will come in handy for rapid prototyping and embedded machine-learning applications. Examples include an HDMI port, camera-input connectors, and PCI-e support, which is not present on a standard Raspberry Pi 4. Finally, the M.2 B-Key port on the rear of the board is not only useful for SSD storage, it can also host a diverse range of PCI-e expansion boards.
Have some info to add for this board? Edit the source for this page [here](https://github.com/adafruit/circuitpython-org/edit/master/_blinka/{{ page.board_id }}.md).
Wouldn't it be cool to drive a tiny OLED display, read a color sensor, or even just flash some LEDs directly from your computer? Sure you can program an Arduino or Trinket to talk to these devices and your computer, but why can't your computer just talk to those devices and sensors itself? Well, now your computer can talk to devices using the Adafruit FT232H breakout board!
What can the FT232H chip do? This chip from FTDI is similar to their USB to serial converter chips but adds a 'multi-protocol synchronous serial engine' which allows it to speak many common protocols like SPI, I2C, serial UART, JTAG, and more! There's even a handful of digital GPIO pins that you can read and write to do things like flash LEDs, read switches or buttons, and more. The FT232H breakout is like adding a little swiss army knife for serial protocols to your computer!
This chip is powerful and useful to have when you want to use Python (for example) to quickly iterate and test a device that uses I2C, SPI or plain general purpose I/O. There's no firmware to deal with, so you don't have to deal with how to "send data to and from an Arduino which is then sent to and from" an electronic sensor or display or part.
The Giant Board is a super tiny single-board computer (SBC) based on the Adafruit Feather form factor. We always want more power in a smaller package, and the Giant Board delivers! It provides a small, powerful platform that is compatible with a wide range of pre-existing accessories. FeatherWing support makes the Giant Board a flexible, drop-in component for most Feather based projects.
We all love our microcontrollers, but in some cases they just don't have the resources we need to carry out the projects we have in mind. By squeezing the power of an SBC into a package the size of a microcontroller board, the Giant Board relaxes memory, storage, and processing constraints and allows you to take your projects to the next level.
The Giant Board fills the gap between microcontrollers and other single-board computers. It makes a great alternative to a Raspberry Pi or BeagleBone in a space constrained project where you need more power than a typical microcontroller can provide. The Giant Board is based on a form factor that is traditionally used for microcontrollers, so power consumption is important, which is why the Giant Board offers low-power modes.
To leverage all that powerful hardware, the Giant Board runs Linux. Not just any Linux, but full Debian Linux! This gives developers and users access to an endless number of applications and libraries for their projects.
Have some info to add for this board? Edit the source for this page [here](https://github.com/adafruit/circuitpython-org/edit/master/_blinka/{{ page.board_id }}.md).
The Coral Dev Board Mini is a single-board computer that provides fast machine learning (ML) inferencing in a small form factor. It's primarily designed as an evaluation device for the Accelerator Module (a surface-mounted module that provides the Edge TPU), but it's also a fully-functional embedded system you can use for various on-device ML projects.
- CPU MediaTek 8167s SoC (Quad-core Arm Cortex-A35)
- GPU IMG PowerVR GE8300 (integrated in SoC)
- ML accelerator Google Edge TPU coprocessor
- RAM 2 GB LPDDR3
- Flash memory 8 GB eMMC
- Wireless Wi-Fi 5 (802.11a/b/g/n/ac); Bluetooth 5.0
**GreatFET One** from [Great Scott Gadgets](https://greatscottgadgets.com/) is a hardware hacker’s best friend. At the center is a powerful NXP LPC4330 (Cortex M4 @ 204MHz) with two USB ports, one host and one peripheral, so it can act as a 'man in the middle' for USB interfacing. With an extensible, open source design, two USB ports, and 100 expansion pins, GreatFET One is your essential gadget for hacking, making, and reverse engineering. By adding expansion boards called neighbors, you can turn GreatFET One into a USB peripheral that does almost anything.
Whether you need an interface to an external chip, a logic analyzer, a debugger, or just a whole lot of pins to bit-bang, the versatile GreatFET One is the tool for you. Hi-Speed USB and a Python API allow GreatFET One to become your custom USB interface to the physical world.
* programmable digital I/O
* serial protocols including SPI, I2C, UART, and JTAG
* logic analysis
* analog I/O (ADC/DAC)
* data acquisition
* debugging
* versatile USB functions including FaceDancer
* high-throughput hardware-assisted streaming serial engine
* four fabulous LEDs!
GreatFET One ships in an ESD bag with a high-speed USB cable and a [wiggler](https://greatscottgadgets.com/wiggler) for easy separation of neighbors. Enclosures and neighbors are sold separately.
GreatFET is a next generation [GoodFET](https://www.adafruit.com/product/1279) intended to serve as your custom Hi-Speed USB peripheral through the addition of expansion boards called “neighbors”.
GreatFET is designed to provide a significant step up in capabilities from [GoodFET](http://github.com/travisgoodspeed/goodfet) while making the design manufacturable at a lower cost than GoodFET. In addition to being designed for automated assembly, it can be hand-assembled with a soldering iron, though it is a more complicated assembly than GoodFET. An important similarity to GoodFET is that GreatFET has a USB bootloader in ROM, so it is possible to build a board by hand and install firmware onto it without the need of any external programming hardware.
We founded SiFive to bring the power of open source to the semiconductor industry. We do this not only by supporting the RISC-V specification, but also by implementing the specification and getting usable chips into the hands of developers as quickly as we can. We did exactly that just over a year ago when we introduced the open source, Arduino-compatible HiFive1 dev board based on our Freedom Everywhere line of 32-bit microcontrollers. Today, we’re proud to be doing the same thing with our Freedom Unleashed 64-bit, Linux-capable system-on-chip (SoC) platform. Meet the HiFive Unleashed, the world’s first RISC-V-based, Linux-capable development board.
Industry skeptics have previously dismissed RISC-V as an academic project, low performance, and only for microcontrollers. HiFive Unleashed, featuring the SiFive Freedom U540 SoC, ends all of that. Linux and RISC-V were meant for each other, and the HiFive Unleashed dev board brings them together for the first time.
Bring your next-gen products to life with the world’s most powerful AI computer for energy-efficient autonomous machines. With up to 275 TOPS and 8X the performance of the last generation for multiple concurrent AI inference pipelines, plus high-speed interface support for multiple sensors, NVIDIA Jetson Orin™ modules provide the ideal solution for a new age of robotics.
The NVIDIA Jetson AGX Orin Developer Kit makes it easy to get started with the Jetson AGX Orin module. Compact size, lots of connectors, and up to 275 TOPS of AI performance make this developer kit perfect for prototyping advanced AI-powered robots and other autonomous machines.
Jetson AGX Orin features an NVIDIA Ampere architecture GPU together with next-generation deep learning and vision accelerators, and its high-speed IO and fast memory bandwidth can feed multiple concurrent AI application pipelines. This means you can develop solutions using your largest and most complex AI models to solve problems such as natural language understanding, 3D perception, and multi-sensor fusion.
NVIDIA JetPack SDK brings the NVIDIA AI software stack to Jetson, along with application development and optimization tools. Software for specific use cases is available, including Isaac for robotics and Metropolis for smart cities, and you can save significant time developing your AI solution when you use your datasets with TAO toolkit to fine-tune pretrained AI models from the NGC catalog.
Jetson ecosystem partners offer additional AI and system software, developer tools, and custom software development. They can also help with cameras and other sensors, as well as carrier boards and design services for your product.
With the computing capability of more than 8 Jetson AGX Xavier systems in a developer kit that integrates the latest NVIDIA GPU technology with the world’s most advanced deep learning software stack, you’ll have the flexibility to create tomorrow’s AI solution as well as today’s.
Have some info to add for this board? Edit the source for this page [here](https://github.com/adafruit/circuitpython-org/edit/master/_blinka/{{ page.board_id }}.md).
NVIDIA Jetson Orin™ Nano Developer Kit is a compact edge AI board built with Jetson Orin™ Nano 8GB module which delivers up to 40TOPS AI performance and has a rich set of IOs including USB 3.2 Gen 2 ports, 2x M.2 Key M for SSD, pre-installed Wi-Fi module, and more.
The NVIDIA Jetson Orin™ Nano Developer Kit sets a new standard for creating entry-level AI-powered robots, smart drones, and intelligent cameras. It also simplifies the process of starting with Jetson Orin Nano series modules. Compact design, lots of connectors, and up to 40 TOPS of AI performance make this the perfect developer kit to bring your AI concepts to life. With up to 80X the performance of Jetson Nano, it can run all modern AI models, including transformer and advanced robotics models.
The developer kit comprises a Jetson Orin™ Nano 8GB module and a reference carrier board that can accommodate all Orin Nano and Orin NX modules. This provides the ideal platform for prototyping your next-gen edge-AI product. The Jetson Orin™ Nano 8GB module features an Ampere architecture GPU and a 6-core ARM CPU, enabling multiple concurrent AI application pipelines and high-performance inference. The carrier board boasts a wide array of connectors, including two camera connectors that can handle 2-lane and 4-lane cameras.
**Features**
- Excellent AI Performance for production: on-device processing with up to 40 TOPS AI performance with low power and low latency
- Hand-size edge AI device: compact size at 100mm x79mm x 21mm, includes Jetson Orin™ Nano 8GB module, a heatsink with a fan and a power adapter.
- Expandable with rich I/Os: USB 3.2 Gen 2 ports(4x), DP 1.2, M.2 key E with pre-installed Wi-Fi module, 2x M.2 Key M for SSD, microSD slot, 2x MIPI CSI-2 connectors, Gigabit Ethernet, 40-pin GPIO
Based on [Jetson Orin NX Module](https://www.nvidia.com/en-us/autonomous-machines/embedded-systems/jetson-orin/), with [JETSON-IO-BASE-B](https://www.waveshare.com/jetson-xavier-nx-dev-kit.htm?sku=22452) base board, providing rich peripheral interfaces such as M.2, HDMI, USB, etc., which is more convenient for users to realize the product performance.
This kit includes the Orin NX Module with options for 8GB/16GB memory, no built-in storage module, provides up to 70 TOPS/100 TOPS AI Performance. Comes with a Free 128 GB NVMe Solid State Drive, high-speed reading/writing, meet the needs of large AI project development.
The world's first supercomputer on a module, Jetson TX1 is capable of delivering the performance and power efficiency needed for the latest visual computing applications. It's built around the revolutionary NVIDIA Maxwell™ architecture with 256 CUDA cores delivering over 1 TeraFLOPs of performance. 64-bit CPUs, 4K video encode and decode capabilities, and a camera interface capable of 1400 MPix/s make this the best system for embedded deep learning, computer vision, graphics, and GPU computing.
The Jetson TX2 Developer Kit gives you a fast, easy way to develop hardware and software for the Jetson TX2 AI supercomputer on a module. It exposes the hardware capabilities and interfaces of the developer board, comes with design guides and other documentation, and is pre-flashed with a Linux development environment.
It also supports NVIDIA Jetpack—a complete SDK that includes the BSP, libraries for deep learning, computer vision, GPU computing, multimedia processing, and much more.
- GPU NVIDIA Pascal™ Architecture GPU
- CPU 2 Denver 64-bit CPUs + Quad-Core A57 Complex
- Memory 8 GB L128 bit DDR4 Memory
- Storage 32 GB eMMC 5.1 Flash Storage
- Connectivity to 802.11ac Wi-Fi and Bluetooth-Enabled Devices
NVIDIA® Jetson™ TX2 NX delivers the next step in AI performance for entry-level embedded and edge products. It provides up to 2.5X the performance of Jetson Nano, and shares form-factor and pin compatibility with Jetson Nano and Jetson Xavier™ NX.
This small module packs hardware accelerators for the entire AI pipeline, and NVIDIA JetPack™ SDK provides the tools you need to use them for your application. Custom AI network development is easy with pre-trained AI models from NVIDIA NGC™ and the NVIDIA Transfer Learning Toolkit, and containerized deployments make updates for your product flexible and seamless.
Ease of development and speed of deployment—plus a unique combination of form-factor, performance, and power advantage—make Jetson TX2 NX the ideal mass-market AI product platform.
- AI Performance: 1.33 TFLOPs
- GPU: NVIDIA Pascal™ Architecture GPU with 256 CUDA cores
- CPU: Dual-core NVIDIA Denver 2 64-bit CPU and quad-core ARM A57 Complex
With the NVIDIA Jetson AGX Xavier developer kit, you can easily create and deploy end-to-end AI robotics applications for manufacturing, delivery, retail, agriculture, and more.
Supported by NVIDIA JetPack and DeepStream SDKs, as well as CUDA®, cuDNN, and TensorRT software libraries, the kit provides all the tools you need to get started right away. And because it’s powered by the new NVIDIA Xavier processor, you now have more than 20X the performance and 10X the energy efficiency of its predecessor, the NVIDIA Jetson TX2.
- GPU 512-core Volta GPU with Tensor Cores
- CPU 8-core ARM v8.2 64-bit CPU, 8MB L2 + 4MB L3
- Memory 16GB 256-Bit LPDDR4x | 137GB/s
- Storage 32 GB eMMC 5.1
- Connectivity to 802.11ac Wi-Fi and Bluetooth-Enabled Devices
- 10/100/1000BASE-T Ethernet
- Video: (2x) 4Kp60 | HEVC/(2x) 4Kp60 | 12-Bit Support
- USB-C 2x USB 3.1, DP (Optional), PD (Optional) Close-System Debug and Flashing Support on 1 Port
Jetson Xavier NX delivers up to 21 TOPS for running modern AI workloads, consumes as little as 10 watts of power, and has a compact form factor smaller than a credit card. It can run modern neural networks in parallel and process data from multiple high-resolution sensors, opening the door for embedded and edge computing devices that demand increased performance but are constrained by size, weight, and power budgets.
- GPU 384-core NVIDIA Volta™ GPU with 48 Tensor Cores
- CPU 800/1100 MHz 6-core NVIDIA Carmel ARM®v8.2 64-bit CPU 6MB L2 + 4MB L3
- Memory 8 GB 128-bit LPDDR4x @ 1600 MHz 51.2GB/s
- Storage 16 GB eMMC 5.1
- Power 10/15W
- PCIe 1 x1 + 1x4
- CSI Camera Up to 6 cameras (36 via virtual channels)
- High Performance: Amlogic A311D - x4 2.2Ghz Cortex A73, x2 1.8Ghz Cortex A53 12nm SoC fabrication process for low heat 2T2R AC Wi-Fi with RSDB Features Bluetooth 5.0 USB 3.0 Available Gigabit Ethernet with WOL support LPDDR4/X USB-C PD for heavy applications
- Neural Network Accelerator: NPU: Supports a maximum frequency of 800MHz at 5.0 TOPS INT8 inference up to 1536 MAC Internal L2 cache (512KB) and system workspace buffer (1MB) Supports all major deep learning frameworks including TensorFlow and Caffe
- Maker Friendly: Stackable Design Programmable MCU 3 Programmable LEDs (Blue, Red and White) XPWR for external Power button Onboard SPI Flash Khadas TST Khadas KBI
- Business Applications Dual independent displays with GSensor H.264 / H.265 Encoding Supports multi-video decoding up to 4Kx2K@60fps+1x1080P@60fps VIN Power Input
- Rich IO: 40 Pin GPIO Header (USB, I2C, I2S, UART, ADC etc) 8-ch I2S for Microphone Array application (over M.2 Connector) MIPI-DSI MIPI-CSI Designed with GPIO Extender Chip
LeMaker Banana Pro is an updated version of its predecessor Banana Pi, a low-cost single-board computer.
The Banana Pro is a credit card-sized and low-power single-board computer developed in China by the LeMaker Team, with the goal of promoting STEM (science, technology, engineering and mathematics) education in schools.
Like its smaller sibling the Banana Pi, the Pro concept is heavily influenced by the Raspberry Pi, however the Banana Pro provides various enhancements over prior designs.
The Banana Pro has an Allwinner A20 system on a chip (SoC), which includes an ARM Cortex-A7 Dual-core (ARMv7-A) 1 GHz, Mali-400 MP2 GPU and 1GB DDR3 SDRAM.
The Banana Pro uses a microSD card for booting an OS, but also includes a SATA 2.0 interface to allow connection of a hard disk for additional storage, however you cannot boot from the hard disk.
Other differences from the Banana Pi include on-board Wi-Fi 802.11b/g/n AP6181, integrated composite video and audio output into a 3.5 mm TRRS jack. This makes space for a 40-pin extension header.
Le Potato is our flagship hardware platform with support for the latest Android 9/TV, upstream Linux, u-boot, Kodi, and more. Based on a long term supported SoC family with a proven record of mass deployments by the largest regional content providers, Google, and Amazon, AML-S905X-CC is the perfect development platform for projects that require highly performant ARM Cortex-A class CPUs, secure and non-secure 4K media delivery and playback, Widevine CAS DRM, high reliability, and low power.
Libre Computer is the only solutions provider with key expertise in both hardware design and upstream free-open-source software (FOSS) stack for Amlogic's GXL SoC family including S805X, S905D, S905W, S905X, and S912. This SoC family features the Amlogic Video Engine 10 (AVE10) capable of handling H.265, H.264, and VP9 streams with HDR metadata making it ideal for 4K digital signage on mainline Linux and the latest Android 9.0 Pie.
Features
- Form Factor Compatible with Raspberry Pi® 2/3 Model B/B+
The ROC-RK3328-CC platform is built on the Rockchip RK3328 system-on-chip optimized for low cost, low power, and high performance IO. It features a high performance native USB 3.0 interface and Gigabit MAC. Libre Computer is one of the few Linux-based software and hardware solutions provider for this chip.
**Product Features**
- Form Factor Compatible with Raspberry Pi® 2/3 Model B/B+
Lichee Pi 4A is a high performance RISC-V linux development board using Lichee Module 4A, based on the TH1520 SoC. It contains 4TOPS@int8 AI NPU, supports 16GB LPDDR4X memory and 128G eMMC storage, supports dual 4K resolution screen display, supports 4K mipi camera input, dual POE Gigabit Ethernet ports and multiple USB interfaces. There is an extra RISC-V C906 Core for audio decode.
Lichee RV Dock is a RISC-V Linux development kit. It expands the module’s usable interfaces by providing an HDMI port with support for up to 4K@30fps output, a 40-pin header with GPIO and power switches, among other things, plus headers and connectors that you can use for speakers, microphones, and more. It supports RGB and MIPI screen interfaces with its screen convert board. There is an onboard 2.4G WIFI+BT module, a 2.4G Patch antenna, an IPEX connector, and a USB Type-A host. The highest network speed is up to 30Mbps (with RTL8723DS), and the average network bandwidth is about 20Mbps.
For software, Lichee RV Dock supports Tina Linux, Debian Officially, and also Ubuntu/OpenSUSE, RustSBI community.
The features of high integration, small size, affordable price, and open-source are suitable for developers exploring more interesting Linux applications. No more waiting and soldering, it greatly shortens the developer’s research and development time by just simply connecting the kit to the display devices and input devices such as a keyboard or a mouse(only available on the Debian system).
LubanCat-4 is equipped with a quad-core A76+quad-core A55 eight-core CPU and a powerful Arm high-performance GPU, and has a built-in NPU with 6T computing power. Equipped with a Gigabit network port, mini-HDMI, USB3.0, MINI PCI-E interface, MIPI and other peripherals. While introducing high-usage interfaces, some low-usage interfaces and peripherals are deleted, significantly reducing the board area, and the reserved universal interfaces such as USB and MINI PCI-E are further expanded. In the usage scenarios of the board, the small body can still burst out great performance.
This allows LubanCat-4 to be used not only as a high-performance single-board computer, but also as an embedded motherboard for display, control, network transmission, file storage, edge computing and other scenarios.
The LubanCat-4 board provides a complete SDK driver development package, design schematics and other resources, which helps users further apply the board while greatly reducing the secondary development time based on this board and accelerating product launch.
Meet the new i.MX6ULL ARM Cortex A7 processor from NXP, it is a high performance and power-efficient processor with a frequency up to 800MHz!
The NPi i.MX6ULL Dev Board is a low power consumption Linux single board computer built around the powerful i.MX6ULL. You would love the onboard 512MB DDR3L and 512MB NAND, not to mention the rich interfaces and I/O resources.
The whole board is made by a core module and a breakout board, and the components are all industrial grade.
The core module is composed of the i.MX6ULL core and 512MB DDR3L, 512MB NAND FLASH(or 8GB eMMC).
The breakout board mainly includes various peripheral interfaces and input and output, IO expansion. Including but not limited to two 100M ethernet port, one USB Host and one USB OTG port, one 24bit RGB LCD Interface, 2x 40 Pin I/O expansion header, etc. Such a wealth of resources will meet your various control needs. All those features make it a perfect solution for industrial control, rail transit, drone control, and audio output, etc.
Wouldn't it be cool to drive a [tiny OLED display](https://www.adafruit.com/categories/98), read a [color sensor](https://www.adafruit.com/products/1334), or even just flash some LEDs directly from your computer? Sure you can program an [Arduino](https://www.adafruit.com/products/50) or [Trinket](https://www.adafruit.com/products/2000) to talk to these devices and your computer, but why can't your computer just talk to those devices and sensors itself? Well, now your computer _can_ talk to devices using the Adafruit MCP2221A breakout board!
What can the MCP2221 chip do? This chip from [Microchip](https://www.microchip.com/wwwproducts/en/MCP2221A) is similar to a USB to serial converter chips but adds a GPIO and I2C interface as well. The analog/digital GPIO pins can act as 10-bit analog inputs (ADC) and there's even a 5-bit DAC output. The I2C interface is great for talking to OLEDs, sensors, PWM drivers, its the most popular interface for small devices. You can use the GPIO to do things like flash LEDs, read switches or buttons, and more. The MCP2221A breakout is like adding a little swiss army knife for serial protocols to your computer!
This chip is powerful and useful to have when you want to use Python (for example) to quickly iterate and test a device that uses I2C or general purpose digital and analog I/O. There's no firmware to deal with, so you don't have to deal with how to "send data to and from an Arduino which is then sent to and from" an electronic sensor or display or part.
Milk-V Duo is an ultra-compact embedded development platform based on the CV1800B chip. It can run Linux and RTOS, providing a reliable, low-cost, and high-performance platform for professionals, industrial ODMs, AIoT enthusiasts, DIY hobbyists, and creators.
- 1GHz and 700MHz RISC-V C906 processors
- Integrated CVITEK TPU for smart detection.
- SIP DRAM 64MB
- Supports H.264/H.265 video encoding, up to 2880x1620@20fps.
- Compatible with high-definition CMOS sensors.
- Programmable frequency output for sensor clock.
- Comprehensive ISP features for image optimization.
- Partial OpenCV library support with CV hardware acceleration.
- 16-bit audio codec with built-in mic input and output functions.
- Flexible network configurations with 1 Ethernet PHY.
The NanoPi Duo2("Duo2") is an ARM board designed and developed by FriendlyELEC for makers and hobbyists. It is only 55 x 25.4mm. It features Allwinner quad-core A7 processor H3, and has 256M/512M DDR3 RAM, onboard WiFi & bluetooth module and an OV5640 camera interface. It works with Linux variants such as Ubuntu Core.
The NanoPi Duo2 is tiny and compact with rich interfaces and ports. It takes power input from its MicroUSB port and can be booted from a Micro SD card. It works with general bread-boards. Interface pins such as USB, SPI, UART, I2C, PWM, IR, audio input & output and Fast Ethernet etc are populated.
The NanoPi Duo2 supports software utilities such as WiringNP and Python etc. These are all open source. It is suited for various IoT applications.
- CPU: Allwinner H3, Quad-core Cortex-A7 Up to 1.2GHz
- DDR3 RAM: 512M
- Connectivity: 10/100M Ethernet
- WiFi: 802.11b/g/n
- Bluetooth: Bluetooth V4.0 of 1, 2 and 3 Mbps.
- Camera: OV5640
- Key: GPIO Key
- USB Host: 2.54mm pin x2, exposed in 2.54mm pitch pin header
- MicroSD Slot x 1
- MicroUSB: OTG and power input
- Debug Serial Interface: exposed in 2.54mm pitch pin header
- Audio input/output Interface: exposed in 2.54mm pitch pin header
- GPIO1: 2.54mm spacing 16pin. It includes UART, SPI, I2C, Audio etc
- GPIO2: 2.54mm spacing 16pin. It includes USB,10/100M Ethernet, IO etc
The OSD32MP1-BRK is a small flexible prototyping platform for the [STM32MP1](https://www.st.com/en/microcontrollers-microprocessors/stm32mp1-series.html) based SiP, the [OSD32MP15x](https://octavosystems.com/octavo_products/osd32mp15x/). At only 3in X 1.8in (75mm X 46mm), it provides easy access to the I/O of the STM32MP1 through a set of breadboard compatible headers. The OSD32MP1-BRK allows developers to quickly build a proof of concept that more closely resembles their actual system without the need to build their own custom hardware.
The OSD32MP1-BRK features the OSD32MP15x System in Package, a microSD slot, 32KHz crystal, a microUSB client port, and two 2×30 100 mill headers. The headers give access to 106 I/O on the STM32MP1 integrated into the OSD32MP15x SiP. It uses a 4 Layer PCB with low cost design rules and has no back side components.
Its minimal overhead and access to a wide range of I/O make the OSD32MP1-BRK the perfect platform for any designer looking for complete flexibility as they prototype their design.
The OSD32MP1-RED is a full featured Reference, Evaluation and Development platform for the [STM32MP1](https://www.st.com/en/microcontrollers-microprocessors/stm32mp1-series.html) based SiP, the [OSD32MP15x](https://octavosystems.com/octavo_products/osd32mp15x/). It provides access to a number of standard communication interfaces like WiFi and Bluetooth, 1Gb Ethernet, and CAN. It supports HDMI or DSI displays and has a connector for a camera. The OSD32MP1-RED expands easily by providing connectors that are compatible with Raspberry Pi, MikroElektronika mikroBUS™ Click, and STMicroelectronics Motor Control Header.
The on board eMMC comes preloaded with an Opensource Linux Distribution allowing you to begin development straight out of the box.
With its communication interfaces, peripherals, and expansion capabilities, the OSD32MP1-RED is a perfect platform for quickly developing IOT, high-end HMI, or real time control applications.
- Full Featured Reference, Evaluation, Development Platform
Have some info to add for this board? Edit the source for this page [here](https://github.com/adafruit/circuitpython-org/edit/master/_blinka/{{ page.board_id }}.md).
ODROID-C4 is a new generation single board computer that is more energy efficient and faster performing than ODROID-C2 which was introduced over four years ago as the world’s first affordable ARM 64bit computer.
The main CPU of the ODROID-C4 is built with a quad-core Cortex-A55 cluster with a new generation Mali-G31 GPU. The A55 cores run at 2.0Ghz without thermal throttling using the stock heat sink allowing a robust and quiet computer. The CPU multi-core performance is around 40% faster, and the system DRAM performance is 50% faster than the ODROID-C2.
- Amlogic S905X3 12nm Processor
- Mali-G31 MP2 GPU with 4 x Execution Engines (650Mhz)
- DDR4 4GiB with 32-bit bus width
- 1x eMMC connector (8/16/32/64GiB are available)
- 1x Micro SD slot (DS/HS mode up to UHS-I SDR104)
- 1 x GbE LAN ports (RJ45, supports 10/100/1000 Mbps)
- 1 x HDMI digital output
- 1 x Optional SPDIF optical output
- 40pin GPIOs + 7pin I2S
- 1 x Debug serial console (UART)
- 4 x USB 3.0 Host ports
- 1 x USB 2.0 OTG port for Host or Device mode. (No power input)
The ODROID-M1 is a single board computer with a wide range of useful peripherals developed for use in a variety of embedded system applications. To achieve this goal, we have developed various hardware accessories and device driver software over the past 10 months. In addition, RK3568B2, the core brain of ODROID-M1, is considered suitable for embedded application use as the SoC manufacturer (Rockchip) guarantees supply for the next 15 years. Therefore, we expect we can supply the ODROID-M1 boards to our important B2B customers until the year 2036 or beyond.
Note that RK3568B2 is a slightly modified version of the RK3568 to overcome the IC supply chain problem these days. The previous RK3568 metal-can type packaging lead time is much longer than the more common plastic package of the RK3568B2.
Let’s take a look at the main features and peripherals of ODROID-M1.
We launched ODROID-M1 about 20 months ago and have supplied it to many B2B and B2C customers. Feedback from many customers requested a lower price, more GPIO ports, lower power consumption, a slimmer form factor, and a variety of practical peripherals.
We would like to introduce you to the ODROID-M1S which was developed over the past six months to respond to market demands. We made the board about 20% thinner, reduced power consumption by about 20%, added 14 header pins, and a built-in 64GB eMMC chip on the board. We have lowered the price to only $49 including a case, heatsink, and power adapter. We believe this will help significantly reduce the cost of building your own affordable and sustainable embedded systems. To ensure longevity, which is important to customers using it for industrial purposes, we will supply this product until at least 2036.
By utilizing 3D modeling from the early PCB design stage, we were able to complete case development relatively precisely and rapidly. It will be remembered for a long time as a novel development project in which collaboration between circuit design & mechanical design proceeded quite smoothly.
Let’s take a look at the main features and peripherals of ODROID-M1S.
ODROID-N2 is a new generation single board computer that is more powerful, more stable, and faster performing than N1.
The main CPU of the N2 is based on big.Little architecture which integrates a quad-core ARM Cortex-A73 CPU cluster and a dual core Cortex-A53 cluster with a new generation Mali-G52 GPU.
Thanks to the modern 12nm silicon technology, the A73 cores runs at 1.8Ghz without thermal throttling using the stock metal-housing heatsink allowing a robust and quiet computer.
The CPU multi-core performance is around 20% faster and the GPU is 10% faster than the N1. The N2’s DDR4 RAM is running at 1320Mhz with 1.2volt low power consumption.
The large metal housing heatsink is designed to optimize the CPU and RAM heat dissipation and minimize throttling. The CPU is placed on the bottom side of the PCB to establish great thermal characteristics.
- Amlogic S922X ARM Cortex-A73(ARMv8-A) 1.8Ghz quad core CPU
ODROID-XU4 is powered by ARM® big.LITTLE™ technology, the Heterogeneous Multi-Processing (HMP) solution.
ODROID-XU4 is a new generation of computing device with more powerful, more energy-efficient hardware and a smaller form factor. Offering open source support, the board can run various flavors of Linux, including the latest Ubuntu 16.04 and Android 4.4 KitKat, 5.0 Lollipop and 7.1 Nougat.
By implementing the eMMC 5.0, USB 3.0 and Gigabit Ethernet interfaces, the ODROID-XU4 boasts amazing data transfer speeds, a feature that is increasingly required to support advanced processing power on ARM devices.
This allows users to truly experience an upgrade in computing, especially with faster booting, web browsing, networking, and 3D games.
- Samsung Exynos5422 Cortex™-A15 2Ghz and Cortex™-A7 Octa core CPUs
- Mali-T628 MP6(OpenGL ES 3.1/2.0/1.1 and OpenCL 1.2 Full profile)
- 2Gbyte LPDDR3 RAM PoP stacked
- eMMC5.0 HS400 Flash Storage
- 2 x USB 3.0 Host, 1 x USB 2.0 Host
- Gigabit Ethernet port
- HDMI 1.4a for display
- Size : 83 x 58 x 20 mm approx.(excluding cooler)
- Power: 5V/4A input
- Linux Kernel 4.14 LTS
- We guarantee the production of XU4 to year 2021, but expect to continue production long after.
is powered by ARM® big.LITTLE™ technology, the Heterogeneous Multi-Processing (HMP) solution.
The ODROID-XU4Q is the same board as the ODROID-XU4 but with a large heatsink instead of a fan which makes it quiet.
ODROID-XU4 is a new generation of computing device with more powerful, more energy-efficient hardware and a smaller form factor. Offering open source support, the board can run various flavors of Linux, including the latest Ubuntu 16.04 and Android 4.4 KitKat, 5.0 Lollipop and 7.1 Nougat.
By implementing the eMMC 5.0, USB 3.0 and Gigabit Ethernet interfaces, the ODROID-XU4 boasts amazing data transfer speeds, a feature that is increasingly required to support advanced processing power on ARM devices.
This allows users to truly experience an upgrade in computing, especially with faster booting, web browsing, networking, and 3D games.
- Samsung Exynos5422 Cortex™-A15 2Ghz and Cortex™-A7 Octa core CPUs
- Mali-T628 MP6(OpenGL ES 3.1/2.0/1.1 and OpenCL 1.2 Full profile)
- 2Gbyte LPDDR3 RAM PoP stacked
- eMMC5.0 HS400 Flash Storage
- 2 x USB 3.0 Host, 1 x USB 2.0 Host
- Gigabit Ethernet port
- HDMI 1.4a for display
- Size : 83 x 58 x 20 mm approx.(excluding cooler)
- Power: 5V/4A input
- Linux Kernel 4.14 LTS
- We guarantee the production of XU4 to year 2021, but expect to continue production long after.
Edge Computing devices are playing an increasingly important role in the field of IoT. Nowadays, a computer is not just a big rectangular black box under the desk, or a small portable device working on your knees. Computers are ubiquitous devices that span calculating, communicating, and data storage. Based on this definition, here we would like to introduce our new product – the ODYSSEY - X86J4105.
ODYSSEY is a series of SBC (Single Board Computer), allowing you to build Edge Computing applications with ease. The ODYSSEY - X86J4105, based on Intel Celeron J4105, is a Quad-Core 1.5GHz CPU that bursts up to 2.5GHz. It includes all the powerful features of Mini PC such as including an 8GB LPDDR4 RAM, 64GB eMMC Storage(optional), onboard Wi-Fi/BLE, Dual Gigabyte Ethernet Ports, Audio Input and Output, USB Ports, HDMI, SATA Connectors and PCIe, however, within a cost-effective price. With simple connections to Mouse, Keyboard and Monitor to ODYSSEY - X86J4105, you will get a Desktop Mini PC right away. With eMMC versions, you even have the Windows 10 Enterprise pre-installed!
Just simply connect to a mouse, a keyboard and a monitor with the ODYSSEY – X86J4105, you will get a powerful Desktop Mini PC that can run Windows and Linux OS.
A20-OLinuXino-LIME2 looks similar to both [A20-OLinuXino-LIME](https://www.olimex.com/wiki/A20-OLinuXino-LIME) and [A10-OLinuXino-LIME](https://www.olimex.com/wiki/A10-OLinuXino-LIME). The major differences between A20-OLinuXino-LIME2 and A20-OLinuXino-LIME are:
- LIME2 has gigabit Ethernet (GbE), compared to the standard 100Mb Ethernet of the LIME
- LIME2 design provides double the RAM memory, compared to the LIME design (1024 vs 512)
- Much better routing of DDR3 memory.
- Increased the number of layers from 6 in LIME to 8 in LIME2
- Corrected pinout of the LCD and GPIO connectors (shields designed for the LIME layout are not compatible with the LIME2 layout)
The A10 and the A20 processors are pin-to-pin compatible. Because of the processor, software-wise the board is closer to [A20-OLinuXino-LIME](https://www.olimex.com/wiki/A20-OLinuXino-LIME) than to the [A10-OLinuXino-LIME](https://www.olimex.com/wiki/A10-OLinuXino-LIME). This resemblance to other designs definitely might speed the development on the board - a lot of software written for A20-OLinuXino-LIME might work out-of-the-box with A20-OLinuXino-LIME2. Additionally, pinout tables, GPIO maps, etc released for A20-OLinuXino-LIME would apply to A20-OLinuXino-LIME2 **(except for the 0.05" step connectors - LCD display and all the GPIOs connectors, which have a different layout compared to both A20-OLinuXino-LIME and A10-OLinuXino-LIME)**.
A20-OLinuXino-LIME2 features:
- A20 Cortex-A7 dual-core ARM Cortex-A7 CPU and dual-core Mali 400 GPU
- **1GB DDR3 RAM memory**
- **1 gigabit native Ethernet**
- optional 4GB NAND FLASH memory
- SATA connector with 5V SATA power jack
- HDMI FullHD 1080p
- 2x USB Low-Full-High-Speed hosts with power control and current limiter
- USB-OTG with power control and current limiter
- LiPo Battery connector with battery-charging capabilities
- LCD connector compatible with with 4.3", 7.0", 10.1" LCD modules from Olimex
- 160 GPIOs on three GPIO connectors
- MicroSD card connector
- DEBUG-UART connector for console debug with USB-SERIAL-CABLE-F
- status LED
- Battery charge status LED
- Power LED
- 2KB EEPROM for MAC address storage and more
- 2 BUTTONS with ANDROID functionality + RESET button
Ever wanted your own Linux-based IoT computer? A small one, that can be battery powered? The Onion Omega2 is sort of in-between a microcontroller (like an Arduino/CircuitPython/MakeCode running chip) and a full-fledged microcomputer (like Raspbery Pi). What you get is a bite-sized development board that combines the power-efficiency of the Arduino and the flexibility of the Raspberry Pi!
So, for example, it runs Linux, but isn't going to replace your desktop computer. It's low power and has a static filesystem, but still requires some time to boot up. It's based on the MediaTek MT7688, a WiFi SoC that was initially designed for devices like WiFi routers or complex IoT devices. It comes with a variant of OpenWRT (nicknamed Onion OS) that is a slimmed down version of Linux. It's not going to run node.js or minecraft but it is Linux. So, you get WiFi built in, and a full TCP/IP stack with SSL/TLS with all the scripting/programming language support that you expect.
Unlike a Raspberry Pi, you don't get a desktop or even a console on HDMI. Instead, you use a serial connection/ssh and the command line, or the simplified webpage interface to program it. So it's good if you have a bit of experience with those things!
Where it excels is as a physical computing platform, with hardware and WiFi. Wanna know how to blink an LED, or even multiple (!) LEDs? You can do that! You'll be able to read switches and use shift registers. Blinking text? No problem! A 7-Segment display and an LCD screen are included! The Maker Kit even comes with relay, PWM/servo and OLED add-ons so you can have a display and robotics interfacing. Comes with all the fixins' to get comfortable with IoT and programming languages, including Python, C++, Node js, php, Bash, Ruby, Perl, Lua, G, and more!
This maker kit has everything you need to fully build and prototype just about any kind of project you can think of with Onion Omega2+. Once you have your project or product well-developed you can then purchase individual Omega2's and add-on boards from Onion.
Orange Pi 2 is for anyone who wants to start creating with technology – not just consuming it. It's a simple, fun, useful tool that you can use to start taking control of the world around you.
- H3 Quad-core Cortex-A7 H.265/HEVC 4K
- Mali400MP2 GPU @600MHz
- Supports OpenGL ES 2.0
- 1GB DDR3 (shared with GPU)
- TF card (Max. 32GB) / MMC card slot
- 10/100M Ethernet RJ45
- A CSI input connector Camera
- Supports 8-bit YUV422 CMOS sensor interface
- Supports CCIR656 protocol for NTSC and PAL
- Supports SM pixel camera sensor
- Supports video capture solution up to 1080p@30fps
- MIC
- Supports HDMI output with HDCP
- Supports HDMI CEC
- Supports HDMI 30 function
- Integrated CVBS
- Supports simultaneous output of HDMI and CVBS
- v3.5 mm Jack and HDMI
- DC input can supply power, but USB OTG input don’t supply power
Orange Pi 3 is for anyone who wants to start creating with technology – not just consuming it. It's a simple, fun, useful tool that you can use to start taking control of the world around you.
### Hardware specification
- H6 Quad-core 64-bit 1.8GHZ ARM Cortex™-A53
- High-performance multi-core GPU Mali T720
- OpenGL ES3.1/3.0/2.0/1.1
- Microsoft DirectX 11 FL9_3
- ASTC(Adaptive Scalable Texture Compression)
- Floating point operation greater than 70 GFLOPS
- AP6256, IEEE 802.11 a/b/g/n/ac, BT5.0
- 10/100M/1000M , ethernet RJ45
- RTL8211
- MIC
- HDMI 2.0a and 3.5 mm AV Jack
- HDMI 2.0a and CVBS
- H265/HEVC Main/Main10 profile@Level5.2 High-tier ;4K@60fps, up to 6Kx4K@30fps
- H264/AVC BP/MP/HP@level5.1, MVC, 4K@30fps
- VP9，Profile 0/2, 4K@30fps
- AVS+/AVS JIZHUN profile@level 6.0, 1080P@60fps
- Supports RC mode
- Supports x1 Gen2(5.0Gbps) lane
- Complies with PCI Express Base 2.0 Specification
Orange Pi 4 is an open-source single-board computer with dual-band wireless WiFi and Bluetooth 5.0. It is highly compact with a dimension of 56 x 91mm.
### Hardware specification
- Rockchip RK3399 (28nm HKMG process)
- 6-core ARM® 64-bit processor, main frequency speeds up to 2.0GHz
- Based on the large and small size core architecture of big.LITTLE
Orange Pi 4 LTS is an open-source single-board computer with dual-band wireless WiFi and Bluetooth 5.0. It is highly compact with a dimension of 56 x 91mm.
Orange Pi 4 LTS uses the Rockchip RK3399(28nm HKMG Process), and has 3 GB /4GB LPDDR4 SDRAM, 16GB EMMC Flash（option）. It can run Android 8.1,Ubuntu16.04,Ubuntu18.04,Debian9. Orange Pi 4 LTS offers a range of different ports, including HDMI output, 26pin headers, LCD connector, Gbps Ethernet port, 2*USB 2.0, 1*USB 3.0, 1*USB 3.0 TYPE-C, mini PCIE connector etc. It is powered through DC and Type-C. It is a good choice for applications that need strong networking perfomance.
### Hardware specification
- Rockchip RK3399 (4GB) or Rockchip RK3399-T(3GB)
- Based on the large and small size of big.LITTLE core architecture:Dual-core Cortex-A72 (large core)+ Quad-core Cortex-A53(small core)
- 6-core ARMR64-bit processor ,main frequency speeds up to 1.6GHz(3GB)/1.8 GHz(4GB)
Orange Pi 5 uses Rockchip RK3588S new generation 8-core 64-bit processor, quad-core A76+quad-core A55, with 8nm process design, up to 2.4GHz main frequency, integrated ARM Mali-G610 GPU, embedded high-performance 3D/2D image acceleration module, built-in NPU with 6Tops computing power, with 4GB/8GB/16GB/32GB (LPDDR4/4x), and up to 8K display processing capability.
Orange Pi 5 provides abundant interfaces, including HDMI output, GPIO interface, M.2 PCIe2.0, Type-C, Gigabit LAN port, 2*USB2.0, 1*USB3.0, etc.; It can be widely used in tablets, edge computing, artificial intelligence, cloud computing, AR/VR, intelligent security, smart home and other fields, covering AIoT various industries.
**Specifications**
- Rockchip RK3588S (8nm LP process)
- 8-core 64-bit processor Big.Little Architecture: 4xCortex-A76 and 4xCortex-A55, Big core cluster is 2.4GHz, and Little core cluster is 1.8GHz frequency.
- Arm Mali-G610 MP4 “Odin” GPU Compatible with OpenGL ES1.1/2.0/3.2, OpenCL 2.2 and Vulkan 1.2 3D graphics engine and 2D graphics engine
- Built-in AI accelerator NPU with up to 6 TOPS, supports INT4/INT8/INT16 mixed operation
- HDMI2.1, up to 8K @60Hz DP1.4 (DisplayPort), DP1.4 and USB3.1 ports are multiplexed, and the port is shared with Type-C 2 * MIPI D-PHY TX 4Lane, configurable up to 4K @60Hz
- MIPI CSI 4Lane 2 * MIPI D-PHY RX 4Lane
- CODEC: ES8388 3.5mm headphone jack audio input/output Input: Onboard MIC HDMI 2.1 eARC
- 10/100/1000Mbps Ethernet
- For extending UART, PWM, I2C, SPI, CAN and GPIO interfaces.
- Support PCIe NVMe SSD Support custom PCIe Wi-Fi6+BT5.0 module
Orange Pi 5 Plus uses Rockchip RK3588 8-core 64-bit processor, quad-core A76+quad-core A55, with 8nm process design, up to 2.4GHz main frequency, integrated ARM Mali-G610, built-in 3D GPU, compatible with OpenGL ES1.1/2.0/3.2, OpenCL 2.2 and Vulkan 1.2; embedded NPU supports INT4/INT8/INT16/FP16 mixed computing, with up to 6Tops of computing power, which can meet the edge computing needs of most end devices; 4GB/8GB/16GB LPDDR4/4X memory and eMMC socket, which can be connected with 16GB/32GB/64GB/128GB/256GB eMMC module. Orange Pi 5 Plus supports Orange Pi OS, the official operating system developed by Orange Pi, as well as Android 12, Debian 11, Ubuntu 22.04 and other operating systems.
Orange Pi 5 Plus provides abundant interfaces, including two HDMl output ports, one HDMl input port , two PCIe extended 2.5G Ethernet ports, an M.2 M-Key slot that supports installation of NVMe SSDs, and an M.2 E-Key slot that supports Wi-Fi6/BT modules. In addition, Orange Pi 5 Plus has two USB 3.0, two USB 2.0, and two Type-C (one of which is a power connector).
Orange Pi 5 Plus has a wide range of uses to help embedded system development enthusiasts explore, and is also suitable for enterprises developing mini machine vision systems with multiple Ethernet ports, Orange Pi 5 Plus offers enhanced high-end applications performance experience to meet the needs of product customization in different industries.
**Specifications**
- Rockchip RK3588 (8nm LP process)
- 8-core 64-bit processor4 x Cortex-A76(2.4GHz), 4 x Cortex-A55(1.8GHz) and separate NEON co-processors
- Arm Mali-G610Built-in 3D GPUCompatible with OpenGL ES1.1/2.0/3.2, OpenCL 2.2 and Vulkan 1.2
- Embedded NPU supports INT4/INT8/INT16/FP16 mixed operation, with up to 6Tops computing power
- RK806-1
- 4GB/8GB/16GB （LPDDR4/4X）
- QSPI Nor FLASH: 16MB/32MBMicroSD card slot: up to 128GBeMMC socket: 16GB/32GB/64GB/128GB/256GB eMMC module can be attachedM.2 2280 slot for NVMe SSDs (PCIe 3.0 x4) up to 2,000 MB/s
- USB3.0 × 2 USB2.0 × 2 Type-C ×1
- 2x HDMI 2.1 out up to 8k@60FPS1x Type-C with DP TX 1.4A，up to 8K@30FPS1x HDMI in with up to 4K@60FPS1 x MIPI DSI TX 4 Lane，up to 4K @60Hz
- 1x 6Pin FPC socket
- 1XMIPI CSI 4 Lane
- CODEC:ES83881xAudio 3.5mm jack with mic1xMIC In1xHDMI 2.1 eARC1xSPK
- 2xPCIe 2.5G LAN（RTL8125BG)
- 40Pin dual row pins with the following multiplexing functions: UART, I2C, SPI, CAN, I2S, PDM, AUDDSM, SDIO, PWM, GPIO
- M.2 connector M key (bottom) for NVMe with PCIe 3.0 x4 lanes 2280 SSD
- M.2 connector E key (top) for connectivity with PCIe 2.0 x1/PCM/UART/USB2.0,2230 Wi-Fi6 /BT supported
It's an open-source single-board computer. It can run Android 4.4, Ubuntu, Debian Image. It uses the AllWinner H3 SoC, and has 512MB DDR3 SDRAM.
What can I do with Orange Pi Lite?
You can use it to build…
A computer
A wireless server
Games
Music and sounds
HD video
A speaker
Android
Scratch
Pretty much anything else, because Orange Pi is open source
Who's it for?
Orange Pi Lite is for anyone who wants to start creating with technology – not just consuming it. It's a simple, fun, useful tool that you can use to start taking control of the world around you.
- H3 Quad-core Cortex-A7 H.265/HEVC 4K
- Mali400MP2 GPU @600MHz
- Supports OpenGL ES 2.0
- 512MB DDR3 (shared with GPU)
- TF card (Max. 32GB) / MMC card slot
- WiFi with external antenna
- A CSI input connector Camera
- Supports 8-bit YUV422 CMOS sensor interface
- Supports CCIR656 protocol for NTSC and PAL
- Supports SM pixel camera sensor
- Supports video capture solution up to 1080p@30fps
- MIC
- Supports HDMI output with HDCP
- Supports HDMI CEC
- Supports HDMI 30 function
- Integrated CVBS
- Supports simultaneous output of HDMI and CVBS
- vDC input can supply power, but USB OTG input don’t supply power
What’s Orange Pi One？ It’s an open-source single-board computer. It can run Android 4.4, Ubuntu, Debian Image. It uses the AllWinner H3 SoC, and has 512MB DDR3 SDRAM
- H3 Quad-core Cortex-A7 H.265/HEVC 4K
- Mali400MP2 GPU @600MHz
- Supports OpenGL ES 2.0
- 512MB DDR3 (shared with GPU)
- TF card (Max. 32GB) / MMC card slot
- 10/100M Ethernet RJ45
- A CSI input connector Camera
- Supports 8-bit YUV422 CMOS sensor interface
- Supports CCIR656 protocol for NTSC and PAL
- Supports SM pixel camera sensor
- Supports video capture solution up to 1080p@30fps
- MIC
- Supports HDMI output with HDCP
- Supports HDMI CEC
- Supports HDMI 30 function
- Integrated CVBS
- Supports simultaneous output of HDMI and CVBS
- vDC input can supply power, but USB OTG input don’t supply power
Have some info to add for this board? Edit the source for this page [here](https://github.com/adafruit/circuitpython-org/edit/master/_blinka/{{ page.board_id }}.md).
It's an open-source single-board computer. It can run Android 4.4 , Ubuntu, Debian Image, it uses the AllWinner H3 SoC, and has 2GB DDR3 SDRAM
What can I do with Orange Pi Plus 2E?
Build…
A computer
A wireless server
Games
Music and sounds
HD video
A speaker
Android
Scratch
Pretty much anything else, because Orange Pi Plus 2E is open source
Who's it for?
Orange Pi Plus 2E is for anyone who wants to start creating with technology – not just consuming it. It's a simple, fun, useful tool that you can use to start taking control of the world around you.
- H3 Quad-core Cortex-A7 H.265/HEVC 4K
- Mali400MP2 GPU @600MHz
- Supports OpenGL ES 2.0
- 2GB DDR3 (shared with GPU)
- 16GB EMMC Flash
- TF card (Max. 32GB) / MMC card slot
- 10/100M Ethernet RJ45
- WiFi - Realtek RTL8189ETV, IEEE 802.11 b/g/n
- A CSI input connector Camera
- Supports 8-bit YUV422 CMOS sensor interface
- Supports CCIR656 protocol for NTSC and PAL
- Supports SM pixel camera sensor
- Supports video capture solution up to 1080p@30fps
- MIC
- Supports HDMI output with HDCP
- Supports HDMI CEC
- Supports HDMI 30 function
- Integrated CVBS
- Supports simultaneous output of HDMI and CVBS
- v3.5 mm Jack and HDMI
- vDC input can supply power, but USB OTG input don’t supply power
- Three USB 2.0 HOST, one USB 2.0 OTG
- Power Button(SW4), Recovery Button(SW3), Uboot Button(SW2)
What’s Orange Pi R1？It’s an open-source single-board computer. It can run Android 4.4, Ubuntu, Debian Image. It uses the AllWinner H2 SoC, and has 256MB DDR3 SDRAM.
What’s Orange Pi R1？It’s an open-source single-board computer. It can run Android 4.4, Ubuntu, Debian Image. It uses the AllWinner H2 SoC, and has 256MB DDR3 SDRAM.
@ -40,7 +40,3 @@ What’s Orange Pi R1？It’s an open-source single-board computer. It can run
Have some info to add for this board? Edit the source for this page [here](https://github.com/adafruit/circuitpython-org/edit/master/_blinka/{{ page.board_id }}.md).
Orange Pi Zero is for anyone who wants to start creating with technology – not just consuming it. It's a simple, fun, useful tool that you can use to start taking control of the world around you.
- H2 Quad-core 32-bit Cortex-A7
- Mali400MP2 GPU @600MHz
- Supports OpenGL ES 2.0
- 256MB DDR3 (shared with GPU)
- TF card (Max. 32GB) / Spi flash(16MB)
- 100M Ethernet RJ45 (onboard 100Mbps)
- Onboard Wifi + Bluetooth
- Realtek RTL8189FTV, IEEE 802.11 b/g/n
- Supports external board via 13 pins
- USB 2.0 HOST and one USB 2.0 OTG
- GPIO(1x3) pin
- UART, ground.
- Power Button(SW602)
- 26 Pin Header
- 13 Pin Header, with 2x USB, IR pin, AUDIO(MIC, AV)
Orange Pi Zero2 is for anyone who wants to start creating with technology – not just consuming it. It's a simple, fun, useful tool that you can use to start taking control of the world around you.
It’s an open-source single-board computer. It can run Android 5.1, Ubuntu, Debian image. It uses the AllWinner H5 SoC, and has 512MB DDR3 SDRAM.
What can I do with Orange Pi Zero Plus?
Build…
A computer
A wireless server
Games
Music and sounds
HD video
A speaker
Android
Scratch
Pretty much anything else, because Orange Pi Zero Plus is open source
Who’s it for?
Orange Pi Zero Plus is for anyone who wants to start creating with technology – not just consuming it. It's a simple, fun, useful tool that you can use to start taking control of the world around you.
- H5 Quad-core Cortex-A53
- H5 Mali450 GPU
- 512MB DDR3 (shared with GPU)
- TF card (Max. 32GB) / Spi flash(2MB)
- Realtek RTL8189FTV, IEEE 802.11 b/g/n
- 1000M/100M/10M Ethernet RJ45
- Supports external board via 13pins
- USB OTG can supply power
- UART, ground
- One USB 2.0 HOST, One USB 2.0 OTG
- Power Button(SW602)
- 26 Pins Header, compatible with Raspberry Pi B+
- 13 Pins Header, with 2x USB, IR pin, AUDIO(MIC, AV)
It’s an open-source single-board computer. It can run Android 4.4(H3 version)/Android 5.1(H5 version) , Ubuntu, Debian, it uses the AllWinner H3/H5 SoC, and has 512MB DDR3 SDRAM.
What can I do with Orange Pi Zero Plus2?
Build…
A computer
A wireless server
Games
Music and sounds
HD video
A speaker
Android
Scratch
Pretty much anything else, because Orange Pi Zero Plus2 is open source
Who's it for?
Orange Pi Zero Plus2 is for anyone who wants to start creating with technology – not just consuming it. It's a simple, fun, useful tool that you can use to start taking control of the world around you.
- H5 Quad-core Cortex-A53
- H3 Quad-core Cortex-A7
- H5 Mali450 GPU
- H3 Mali400MP2 GPU
- 512MB DDR3 (shared with GPU)
- AP6212, IEEE 802.11 b/g/n, BT4.2
- A CSI input connector Camera
- Supports 8-bit YUV422 CMOS sensor interface
- Supports CCIR656 protocol for NTSC and PAL
- Supports SM pixel camera sensor
- Supports video capture solution up to 1080p@30fps
- Supports HDMI output with HDCP
- Supports HDMI CEC
- Supports HDMI 30 function
- USB OTG can supply power
- UART, ground
- PowerButton
- 26 Pins Header, compatible with Raspberry Pi B+
- 13 Pins Header, with 2x USB, IR pin, AUDIO(MIC, AV)
As the field of embedded electronics gets more advanced, hobbyists and professionals are both in need of smaller and more powerful computers. The pcDuino2 is a high performance, cost effective mini PC platform that runs full-featured operating systems such as Ubuntu and Android ICS. Now included with the pcDuino2 is a built in Wi-Fi module and Arduino headers (finally with the same architecture as Uno boards) meaning you will no longer need to purchase a separate wireless module or shield adapter for this dev board!
It’s easy to hook up, just connect 5V power and a keyboard and mouse. The pcDuino2 outputs video to any HDMI enabled TV or monitor via the built in HDMI interface. It was specifically designed to make it easy for the open source community to develop computationally demanding projects using the vast, existing catalog of Arduino Shields.
An API has been developed for the pcDuino2 that allows the user to access all of the functions that you would expect using simple Arduino-style language.
**Features:**
- 1GHz ARM Cortex A8 CPU
- GPU: OpenGL ES2.0, OpenVG 1.1 Mali 400 core
- 1GB DRAM
- Onboard Storage: 4GB Flash, microSD card (TF) slot for up to 32GB
- Arduino-Style Peripheral Headers
- HDMI Video Output
- Linux3.0 + Ubuntu12.04 and Android ICS 4.0 Supported
- 0.1" Spaced GPIO Headers
- RJ45 Ethernet Connection and On-Board Wi-Fi Module
