# CircuitPython Libraries on Linux and the 96Boards DragonBoard 410c ## Overview Info: This guide describes using CircuitPython **libraries** on small Linux computers, running under regular Python. It is not about running the CircuitPython firmware itself on those boards. ![](https://cdn-learn.adafruit.com/assets/assets/000/056/765/medium800/sensors_blinkatux.gif?1530378720) Here at Adafruit we're always looking for ways to make _making easier_ - whether that's making breakout boards for hard-to-solder sensors or writing libraries to simplify motor control. Our new favorite way to program is **CircuitPython**. ## Why CircuitPython? CircuitPython is a variant of MicroPython, a very small version of Python that can fit on a microcontroller. Python is the fastest-growing programming language. It's taught in schools, used in coding bootcamps, popular with scientists and of course programmers at companies use it a lot! CircuitPython adds the Circuit part to the Python part. It lets you program in Python and talk to Circuitry like sensors, motors, and LEDs! ## CircuitPython on Microcontrollers CircuitPython runs on microcontroller boards, such as our Feather, Metro, QT Py, and ItsyBitsy boards, using a variety of chips, such as the MicroChip SAMD21 SAMD51, the Raspberry Pi RP2040, the Nordic nRF52840, and the Espressif ESP32-S2 and ESP32-S3. All of these chips have something in common - they are _microcontrollers_ with hardware peripherals like SPI, I2C, ADCs etc. We squeeze Python into 'em and can then make the project portable. But...sometimes you want to do more than a microcontroller can do. Like HDMI video output, or camera capture, or serving up a website, or just something that takes more memory and computing than a microcontroller board can do... ## CircuitPython Libraries on Desktop Linux By adding a software layer, you can use CircuitPython hardware control capabilities with "regular Python", as found on your desktop or single-board Linux computer/ There are tons of projects, libraries and example code for CircuitPython on microcontrollers, and thanks to the flexibility and power of Python its' pretty easy to get that code working on micro-computers like the Raspberry Pi or other single-board Linux computers with GPIO pins available. You'll use a special library called [**adafruit\_blinka**](https://pypi.org/project/Adafruit-Blinka/) ([named after Blinka, the CircuitPython mascot](https://www.adafruit.com/?q=blinka)) that provides a layer that translates the CircuitPython hardware API to whatever library the Linux board provides. For example, on Raspberry Pi we use the python [RPi.GPIO](https://pypi.org/project/RPi.GPIO/) library. For any I2C interfacing we'll use ioctl messages to the `/dev/i2c` device. For SPI we'll use the `spidev` python library, etc. These details don't matter so much because they all happen underneath the  **adafruit\_blinka**  layer. The upshot is that most code we write for CircuitPython will be instantly and easily runnable on Linux computers like Raspberry Pi. _In particular_, you'll be able to use all of our device drivers - the sensors, led controllers, motor drivers, HATs, bonnets, etc. And nearly all of these use I2C or SPI! The rest of this guide describes how to install and set up Blinka, and then how to use it to run CircuitPython code to control hardware. # CircuitPython Libraries on Linux and the 96Boards DragonBoard 410c ## CircuitPython & DragonBoard ![](https://cdn-learn.adafruit.com/assets/assets/000/077/486/medium800/sensors_blinkapi.png?1561493694) ## CircuitPython Libraries on Linux & 96Boards DragonBoard The next obvious step is to bring CircuitPython ease of use **back** to 'desktop Python'. We've got tons of projects, libraries and example code for CircuitPython on microcontrollers, and thanks to the flexibility and power of Python its pretty easy to get it working with microcomputers like the DragonBoard or other 'Linux with GPIO pins available' single board computers. We'll use a special library called [**adafruit\_blinka**](https://pypi.org/project/Adafruit-Blinka/) ([named after Blinka, the CircuitPython mascot](https://www.adafruit.com/?q=blinka)) to provide the layer that translates the CircuitPython hardware API to whatever library the Linux board provides. For example, on the DragonBoard we use the python **libgpiod** bindings. For any I2C interfacing we'll use ioctl messages to the `/dev/i2c` device. These details don't matter so much because they all happen underneath the **adafruit\_blinka** layer. The upshot is that any code we have for CircuitPython will be instantly and easily runnable on Linux computers like the DragonBoard. _In particular_, we'll be able to use all of our device drivers - the sensors, led controllers, motor drivers, HATs, bonnets, etc. And nearly all of these use I2C or SPI! ## Wait, isn't there already something that does this - libgpiod? [libgpiod is a python hardware interface class](https://www.beyondlogic.org/an-introduction-to-chardev-gpio-and-libgpiod-on-the-raspberry-pi/) that works on the DragonBoard. It works just fine for I2C, SPI and GPIO but doesn't work with our drivers as it's a different API By letting you use CircuitPython libraries on the DragonBoard via **adafruit\_blinka** , you can unlock all of the drivers and example code we wrote! _And_ you can keep using  **libgpiod** if you like. We save time and effort so we can focus on getting code that works in one place, and you get to reuse all the code we've written already. ## What about other Linux SBCs? Yep! Blinka can easily be updated to add other boards. We've started with the ones we've got, so we could test them thoroughly. If you have other SBC board you'd like to adapt [check out the adafruit\_blinka code on github](https://github.com/adafruit/Adafruit_Blinka), pull requests are welcome as there's a _ton_ of different Linux boards out there! # CircuitPython Libraries on Linux and the 96Boards DragonBoard 410c ## Initial Setup Danger: ## Install Linaro on your DragonBoard 410c We decided to try getting Blinka running in Linaro Debian because that's the recommended Debian installation available for the DragonBoard410c. Other distros could be made to work but you'd probably need to figure out how to detect the platform. Using other operating systems and CircuitPython is your call, we cannot provide support for that. Download and install the latest linaro, for example we're using [https://www.96boards.org/documentation/consumer/dragonboard/dragonboard410c/downloads/debian.md.html](https://www.96boards.org/documentation/consumer/dragonboard/dragonboard410c/downloads/debian.md.html) There's some documentation to get started at [https://www.96boards.org/documentation/consumer/dragonboard/dragonboard410c/installation/](https://www.96boards.org/documentation/consumer/dragonboard/dragonboard410c/installation/) Danger: ## Preparing the Board If you are booting from an SD card, there's one small step you'll need to take before you can do that. There's a DIP switch on the underside labeled **SD BOOT** that you'll need to move to the **ON** position. ![sensors_dip_switch.png](https://cdn-learn.adafruit.com/assets/assets/000/077/503/medium640/sensors_dip_switch.png?1561511766) ## Logging in We've found the easiest way to connect is through a console cable, wired to the UART Serial port through a logic level shifter, and then on your computer, use a serial monitor at 115200 baud. Danger: ![](https://cdn-learn.adafruit.com/assets/assets/000/077/489/medium800/sensors_serial_logic_converter_bb.png?1561494913) Featured ### USB to TTL Serial Cable - Debug / Console Cable for Raspberry Pi [USB to TTL Serial Cable - Debug / Console Cable for Raspberry Pi](https://www.adafruit.com/product/954) The cable is easiest way ever to connect to your microcontroller/Raspberry Pi/WiFi router serial console port. Inside the big USB plug is a USB\<-\>Serial conversion chip and at the end of the 36" cable are four wire - red power, black ground, white RX into USB port, and green TX out... In Stock [Buy Now](https://www.adafruit.com/product/954) [Related Guides to the Product](https://learn.adafruit.com/products/954/guides) ![USB to TTL Serial Cable With Type A plug and 4 wire sockets](https://cdn-shop.adafruit.com/640x480/954-02.jpg) Featured ### 4-channel I2C-safe Bi-directional Logic Level Converter [4-channel I2C-safe Bi-directional Logic Level Converter](https://www.adafruit.com/product/757) Because the Arduino (and Basic Stamp) are 5V devices, and most modern sensors, displays, flashcards, and modes are 3.3V-only, many makers find that they need to perform level shifting/conversion to protect the 3.3V device from 5V. Here we've got a ** 4-channel I2C-safe...** In Stock [Buy Now](https://www.adafruit.com/product/757) [Related Guides to the Product](https://learn.adafruit.com/products/757/guides) ![Angled shot of a 4-channel I2C-safe Bi-directional Logic Level Converter.](https://cdn-shop.adafruit.com/640x480/757-06.jpg) Featured ### Half Sized Premium Breadboard - 400 Tie Points [Half Sized Premium Breadboard - 400 Tie Points](https://www.adafruit.com/product/64) This is a cute, half-size breadboard with 400 tie points, good for small projects. It's 3.25" x 2.2" / 8.3cm x 5.5cm with a standard double-strip in the middle and two power rails on both sides. You can pull the power rails off easily to make the breadboard as... In Stock [Buy Now](https://www.adafruit.com/product/64) [Related Guides to the Product](https://learn.adafruit.com/products/64/guides) ![Angled shot of half-size solderless breadboard with red and black power lines.](https://cdn-shop.adafruit.com/640x480/64-06.jpg) Once powered correctly and with the right SD card you should get a command prompt as **root**. You may need to press enter if it appears to stop. ![sensors_serial_connect_first.png](https://cdn-learn.adafruit.com/assets/assets/000/077/493/medium640/sensors_serial_connect_first.png?1561503025) You may want to create a new username, we recommend **pi** - if our instructions end up adding gpio access for the **pi** user, you can copy and paste them. You can do this by typing: `adduser pi` and then add the new user to the sudo group: `usermod -aG sudo pi` ![sensors_newuser.png](https://cdn-learn.adafruit.com/assets/assets/000/077/494/medium640/sensors_newuser.png?1561503485) Just to secure the board, we also recommend you change the linaro user's password, which by default is linaro: `passwd linaro` Be sure to keep the password in a safe place in case you need it. ![sensors_linaro_password_change.png](https://cdn-learn.adafruit.com/assets/assets/000/077/498/medium640/sensors_linaro_password_change.png?1561507898) ![](https://cdn-learn.adafruit.com/assets/assets/000/077/496/medium800/sensors_boot_screen.png?1561507789) Once installed, you may want to enable mdns so you can ssh `pi@linaro-developer` instead of needing to know the IP address. First you will need to update, then install: - `sudo apt update` - `sudo apt install avahi-daemon` then **reboot** ## Connecting to the Network Before you can use your DragonBoard 410c, you will need to connect to a network. The DragonBoard 410c does not come with any ethernet ports, but there's still a couple of different options available. The first option is to get a USB hub with an ethernet line. Featured ### USB 2.0 and Ethernet Hub - 3 USB Ports and 1 Ethernet [USB 2.0 and Ethernet Hub - 3 USB Ports and 1 Ethernet](https://www.adafruit.com/product/2909) One can never have enough socks or USB ports. Add some more USB and Ethernet capability to your Raspberry Pi or, really, any kind of computer with this **USB 2.0 and Ethernet Hub**! This handy combo-hub has 3 USB 2.0 ports and an AX88772A Ethernet transceiver. This... In Stock [Buy Now](https://www.adafruit.com/product/2909) [Related Guides to the Product](https://learn.adafruit.com/products/2909/guides) ![Angled shot of USB-A hub with Ethernet.](https://cdn-shop.adafruit.com/640x480/2909-13.jpg) ## Connecting to WiFi The other option is to connect to an access point with the onboard WiFi.  To see a list of WiFi Access point SSIDs, type: `nmcli dev wifi list` To connect to a WIFI access point, first create the connection, replacing **YOUR\_SSID** with your WiFi name: `nmcli con add con-name WiFi ifname wlan0 type wifi ssid YOUR_SSID` Then set up the password for your access point by enabling WPA PSK. Change this to the appropriate type if your connection is different. `nmcli con modify WiFi wifi-sec.key-mgmt wpa-psk` And add your password, replacing **YOUR\_PASSWORD** with your WiFi password: `nmcli con modify WiFi wifi-sec.psk YOUR_PASSWORD` Finally enable the connection: `nmcli con up WiFi` You can check the connection status by typing: `nmcli connection show` ![](https://cdn-learn.adafruit.com/assets/assets/000/077/506/medium800/sensors_wifi_status.png?1561512727) ## Set your Python install to Python 3 Default There's a few ways to do this, we recommend something like this: - ` sudo apt install -y python3 git python3-pip` - `sudo update-alternatives --install /usr/bin/python python /usr/bin/python2.7 1` - `sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.7 2` - `sudo update-alternatives --config python` Of course, change the version numbers if a newer version of Python is distributed. ## Update Your Board and Python Run the standard updates: `sudo apt update` `sudo apt upgrade` Choose UTF-8 for character set if prompted and `sudo pip3 install --upgrade setuptools` Update all your Python 3 packages with `pip3 freeze - local | grep -v '^\-e' | cut -d = -f 1 | xargs -n1 pip3 install -U` and `sudo bash` ` pip3 freeze - local | grep -v '^\-e' | cut -d = -f 1 | xargs -n1 pip3 install -U` ## Install libgpiod libgpiod is what we use for gpio toggling. Fortunately it's available for the DragonBoard 410c. You can install it with the following command: ```terminal sudo apt install libgpiod2 python3-libgpiod gpiod ``` ![](https://cdn-learn.adafruit.com/assets/assets/000/104/589/medium800/sensors_libgpiod_install.png?1631572505) After installation, you should be able to `import gpiod` from within Python 3: ![](https://cdn-learn.adafruit.com/assets/assets/000/077/501/medium800/sensors_libgpiod3.png?1561509378) ## Enable UART, I2C and SPI A vast number of our CircuitPython drivers use UART, I2C and SPI for interfacing, so you'll want to get those enabled. You only have to do this _once_ per board, unfortunately by default the SPI interface is disabled! Install the support software with: - `sudo apt install -y python-smbus python-dev i2c-tools` - `sudo adduser pi i2c` ![sensors_i2c-tools.png](https://cdn-learn.adafruit.com/assets/assets/000/077/509/medium640/sensors_i2c-tools.png?1561513232) To use SPI, you will need to enable **SPIDEV** by running the following commands to modify the device tree node: `cd ~` `git clone https://github.com/96boards/dt-update` `cd dt-update` `make` `sudo scripts/db410c/enable-spidev.sh` ![sensors_spidev.png](https://cdn-learn.adafruit.com/assets/assets/000/077/515/medium640/sensors_spidev.png?1561515208) Once you're done with both and have rebooted, verify you have the I2C and SPI devices with the command `ls /dev/i2c* /dev/spi*` You should see at least one i2c device and one spi device ![](https://cdn-learn.adafruit.com/assets/assets/000/077/512/medium800/sensors_i2c_spi_ports.png?1561514595) ![](https://cdn-learn.adafruit.com/assets/assets/000/077/513/medium800/sensors_i2cdetect.png?1561514669) You can test to see what I2C addresses are connected by running `sudo i2cdetect -r -y 0`(on **pins 15/17** ) or `sudo i2cdetect -r -y 1` (on  **pins 19/21** ) In this case I do have a sensor on the 'standard' i2c port i2c-0 under address 0x77 ![sensors_i2cdevices.png](https://cdn-learn.adafruit.com/assets/assets/000/077/519/medium640/sensors_i2cdevices.png?1561517138) The UART1 Serial Console on the DragonBoard 410c is connected to **/dev/ttyMSM0**. The UART1 GPIO Serial Port is connected to **/dev/ttyMSM1**. ## Install Python Libraries Now you're ready to install all the Python support. Run the following command to install **wheel** and **flask** : `sudo pip3 install wheel flask` Next, run the following command to install **adafruit\_blinka** : `sudo pip3 install adafruit-blinka``` ![](https://cdn-learn.adafruit.com/assets/assets/000/076/812/medium800/sensors_blinka_install.png?1560215445) The computer will install a few different libraries such as `adafruit-pureio` (our ioctl-only i2c library),  `Adafruit-GPIO` (for detecting your board) and of course `adafruit-blinka`. That's pretty much it! You're now ready to test. Create a new file called **blinkatest.py** with **nano** or your favorite text editor and put the following in: ```auto import board import digitalio import busio print("Hello blinka!") # Try to great a Digital input pin = digitalio.DigitalInOut(board.GPIO_A) print("Digital IO ok!") # Try to create an I2C device i2c = busio.I2C(board.SCL, board.SDA) print("I2C ok!") # Try to create an SPI device spi = busio.SPI(board.SCLK, board.MOSI, board.MISO) print("SPI ok!") print("done!") ``` Save it and run at the command line with `sudo python3 blinkatest.py` You should see the following, indicating digital i/o, I2C and SPI all worked ![](https://cdn-learn.adafruit.com/assets/assets/000/077/521/medium800/sensors_blinkatest.png?1561518278) # CircuitPython Libraries on Linux and the 96Boards DragonBoard 410c ## Digital I/O The first step with any new hardware is the 'hello world' of electronics - blinking an LED. This is very easy with CircuitPython and DragonBoard410c. We'll extend the example to also show how to wire up a button/switch. Danger: ![](https://cdn-learn.adafruit.com/assets/assets/000/077/492/medium800/sensors_db_pinout.png?1561497319) Info: ## Parts Used Any old LED will work just fine as long as it's not an IR LED (you can't see those) and a 470 to 2.2K resistor Featured ### Through-Hole Resistors - 470 ohm 5% 1/4W - Pack of 25 [Through-Hole Resistors - 470 ohm 5% 1/4W - Pack of 25](https://www.adafruit.com/product/2781) ΩMG! You're not going to be able to resist these handy resistor packs! Well, axially, they do all of the resisting for you! This is a **25 Pack of 470Ω Resistors.** More specifically, they are **carbon film** , through-hole... In Stock [Buy Now](https://www.adafruit.com/product/2781) [Related Guides to the Product](https://learn.adafruit.com/products/2781/guides) ![Angled shot of 25 Through-Hole Resistors - 470 ohm 5% 1/4W.](https://cdn-shop.adafruit.com/640x480/2781-00.jpg) Some tactile buttons or switches: Featured ### Tactile Switch Buttons (12mm square, 6mm tall) x 10 pack [Tactile Switch Buttons (12mm square, 6mm tall) x 10 pack](https://www.adafruit.com/product/1119) Medium-sized clicky momentary switches are standard input "buttons" on electronic projects. These work best in a PCB but [can be used on a solderless breadboard as shown in this tutorial](https://learn.adafruit.com/adafruit-arduino-lesson-6-digital-inputs?view=all). The... In Stock [Buy Now](https://www.adafruit.com/product/1119) [Related Guides to the Product](https://learn.adafruit.com/products/1119/guides) ![Angled shot of 10 12mm square tactile switch buttons.](https://cdn-shop.adafruit.com/640x480/1119-03.jpg) Because the DragonBoard 410c uses 1.8V logic levels, you will need a logic level converter to interface with most peripherals. Featured ### 4-channel I2C-safe Bi-directional Logic Level Converter [4-channel I2C-safe Bi-directional Logic Level Converter](https://www.adafruit.com/product/757) Because the Arduino (and Basic Stamp) are 5V devices, and most modern sensors, displays, flashcards, and modes are 3.3V-only, many makers find that they need to perform level shifting/conversion to protect the 3.3V device from 5V. Here we've got a ** 4-channel I2C-safe...** In Stock [Buy Now](https://www.adafruit.com/product/757) [Related Guides to the Product](https://learn.adafruit.com/products/757/guides) ![Angled shot of a 4-channel I2C-safe Bi-directional Logic Level Converter.](https://cdn-shop.adafruit.com/640x480/757-06.jpg) We recommend using a breadboard and some male-male wires. Featured ### Premium Male/Male Jumper Wires - 40 x 6" (150mm) [Premium Male/Male Jumper Wires - 40 x 6" (150mm)](https://www.adafruit.com/product/758) Handy for making wire harnesses or jumpering between headers on PCB's. These premium jumper wires are 6" (150mm) long and come in a 'strip' of 40 (4 pieces of each of ten rainbow colors). They have 0.1" male header contacts on either end and fit cleanly next to each other... Out of Stock [Buy Now](https://www.adafruit.com/product/758) [Related Guides to the Product](https://learn.adafruit.com/products/758/guides) ![Angled shot of Premium Male/Male Jumper Wires - 40 x 6 (150mm)](https://cdn-shop.adafruit.com/640x480/758-04.jpg) Featured ### Half Sized Premium Breadboard - 400 Tie Points [Half Sized Premium Breadboard - 400 Tie Points](https://www.adafruit.com/product/64) This is a cute, half-size breadboard with 400 tie points, good for small projects. It's 3.25" x 2.2" / 8.3cm x 5.5cm with a standard double-strip in the middle and two power rails on both sides. You can pull the power rails off easily to make the breadboard as... In Stock [Buy Now](https://www.adafruit.com/product/64) [Related Guides to the Product](https://learn.adafruit.com/products/64/guides) ![Angled shot of half-size solderless breadboard with red and black power lines.](https://cdn-shop.adafruit.com/640x480/64-06.jpg) ## Wiring - Connect the DragonBoard  **Ground** pin to the **blue ground rail** on the breadboard - Connect the DragonBoard  **+5V** pin to the **red 5V rail** on the breadboard. - Connect the DragonBoard **+1.8V** pin to the **LV pin** on the Logic Level Converter - Connect the  **HV pin** on the Logic Level Converter to the  **5V rail** - Connect the **Ground pin**  on the Logic Level Converter to the  **blue ground rail**  on the breadboard  - Connect one side of the tactile switch to the  **B1 pin**  on the Logic Level Converter - Connect a ~10K pull up resistor from **B1** to the  **5V rail** - Connect the other side of the tactile switch to the **ground** rail - Connect the longer/positive pin of the LED to the  **B2 pin**  on the Logic Level Converter - Connect the shorter/negative pin of the LED to a 470ohm to 2.2K resistor, the other side of the resistor goes to **ground** rail - Connect the DragonBoard **GPIO\_B pin** (GPIO 12) to the  **A1 pin**  on the Logic Level Converter - Connect the DragonBoard **GPIO\_A pin** (GPIO 36) to the  **A2 pin**  on the Logic Level Converter ![](https://cdn-learn.adafruit.com/assets/assets/000/077/539/medium800/sensors_digitalio_logic_converter_bb.png?1561600306) [digitalio_logic_converter.fzz](https://cdn-learn.adafruit.com/assets/assets/000/077/532/original/digitalio_logic_converter.fzz?1561580648) Double-check you have the right wires connected to the right location, it can be tough to keep track of GPIO pins as there are forty of them! No additional libraries are needed so we can go straight on to the example code However, we recommend running a pip3 update! `sudo pip3 install --upgrade adafruit_blinka` ## Blinky Time! The finish line is right up ahead, let's start with an example that blinks the LED on and off once a second (half a second on, half a second off): ```auto import time import board import digitalio print("hello blinky!") led = digitalio.DigitalInOut(board.GPIO_A) led.direction = digitalio.Direction.OUTPUT while True: led.value = True time.sleep(0.5) led.value = False time.sleep(0.5) ``` Verify the LED is blinking. If not, check that it's wired to the correct Logic Level Converter channel, that the Logic Level channel is connected to  **GPIO\_A**  or **GPIO\_36** , the resistor is installed correctly, and you have a Ground wire to the DragonBoard. Also, be sure to check the Power and Ground wires to the Logic Level Converter. Type Control-C to quit ## Button It Up Now that you have the LED working, let's add code so the LED turns on whenever the button is pressed: ```auto import time import board import digitalio print("press the button!") led = digitalio.DigitalInOut(board.GPIO_A) led.direction = digitalio.Direction.OUTPUT button = digitalio.DigitalInOut(board.GPIO_B) button.direction = digitalio.Direction.INPUT # use an external pullup since we don't have internal PU's #button.pull = digitalio.Pull.UP while True: led.value = not button.value # light when button is pressed! ``` Press the button - see that the LED lights up! Type Control-C to quit # CircuitPython Libraries on Linux and the 96Boards DragonBoard 410c ## I2C Sensors & Devices The most popular electronic sensors use _I2C_ to communicate. This is a 'shared bus' 2 wire protocol, you can have multiple sensors connected to the two SDA and SCL pins as long as they have unique addresses ([check this guide for a list of many popular devices and their addresses](https://learn.adafruit.com/i2c-addresses)) Lets show how to wire up a popular BME280. This sensor provides temperature, barometric pressure and humidity data over I2C We're going to do this in a lot more depth than our guide pages for each sensor, but the overall technique is basically identical for any and all I2C sensors. Honestly, the hardest part of using I2C devices is [figuring out the I2C address](https://learn.adafruit.com/i2c-addresses) and which pin is SDA and which pin is SCL! ## Parts Used Featured ### Adafruit BME280 I2C or SPI Temperature Humidity Pressure Sensor [Adafruit BME280 I2C or SPI Temperature Humidity Pressure Sensor](https://www.adafruit.com/product/2652) Bosch has stepped up their game with their new BME280 sensor, an environmental sensor with temperature, barometric pressure and humidity! This sensor is great for all sorts of indoor environmental sensing and can even be used in both I2C and SPI! This precision sensor from... In Stock [Buy Now](https://www.adafruit.com/product/2652) [Related Guides to the Product](https://learn.adafruit.com/products/2652/guides) ![small, rectangle-shaped, BME280 temperature humidity pressure sensor breakout board.](https://cdn-shop.adafruit.com/640x480/2652-04.jpg) Because the DragonBoard 410c uses 1.8V logic levels, you will need a logic level converter to interface with most peripherals. Featured ### 4-channel I2C-safe Bi-directional Logic Level Converter [4-channel I2C-safe Bi-directional Logic Level Converter](https://www.adafruit.com/product/757) Because the Arduino (and Basic Stamp) are 5V devices, and most modern sensors, displays, flashcards, and modes are 3.3V-only, many makers find that they need to perform level shifting/conversion to protect the 3.3V device from 5V. Here we've got a ** 4-channel I2C-safe...** In Stock [Buy Now](https://www.adafruit.com/product/757) [Related Guides to the Product](https://learn.adafruit.com/products/757/guides) ![Angled shot of a 4-channel I2C-safe Bi-directional Logic Level Converter.](https://cdn-shop.adafruit.com/640x480/757-06.jpg) We recommend using a breadboard and some male-male wires. Featured ### Premium Male/Male Jumper Wires - 40 x 6" (150mm) [Premium Male/Male Jumper Wires - 40 x 6" (150mm)](https://www.adafruit.com/product/758) Handy for making wire harnesses or jumpering between headers on PCB's. These premium jumper wires are 6" (150mm) long and come in a 'strip' of 40 (4 pieces of each of ten rainbow colors). They have 0.1" male header contacts on either end and fit cleanly next to each other... Out of Stock [Buy Now](https://www.adafruit.com/product/758) [Related Guides to the Product](https://learn.adafruit.com/products/758/guides) ![Angled shot of Premium Male/Male Jumper Wires - 40 x 6 (150mm)](https://cdn-shop.adafruit.com/640x480/758-04.jpg) Featured ### Half Sized Premium Breadboard - 400 Tie Points [Half Sized Premium Breadboard - 400 Tie Points](https://www.adafruit.com/product/64) This is a cute, half-size breadboard with 400 tie points, good for small projects. It's 3.25" x 2.2" / 8.3cm x 5.5cm with a standard double-strip in the middle and two power rails on both sides. You can pull the power rails off easily to make the breadboard as... In Stock [Buy Now](https://www.adafruit.com/product/64) [Related Guides to the Product](https://learn.adafruit.com/products/64/guides) ![Angled shot of half-size solderless breadboard with red and black power lines.](https://cdn-shop.adafruit.com/640x480/64-06.jpg) # Wiring - Connect the DragonBoard  **Ground** pin to the  **ground**  on the Logic Level Converter - Connect the DragonBoard  **+5V** pin to the **red 5V rail** on the breadboard. - Connect the DragonBoard **+1.8V** pin to the **LV pin** on the Logic Level Converter - Connect the  **HV pin** on the Logic Level Converter to the  **5V rail** - Connect the **Vin pin**  on the BME280 to the **red 5V rail ** on the breadboard  - Connect the **Ground pin**  on the BME280 to the  **ground**  on the Logic Level Converter - Connect the  **B1 pin**  on the Logic Level Converter to the BME280 **SCK** - Connect the  **B2 pin**  on the Logic Level Converter to the BME280 **SDI** - Connect the DragonBoard **I2C0 SCL**  to the  **A1 pin**  on the Logic Level Converter - Connect the DragonBoard  **I2C0 SDA**  to the  **A2 pin**  on the Logic Level Converter Danger: ![](https://cdn-learn.adafruit.com/assets/assets/000/077/541/medium800/sensors_i2c_logic_converter_bb.png?1561601566) [i2c_logic_converter.fzz](https://cdn-learn.adafruit.com/assets/assets/000/077/542/original/i2c_logic_converter.fzz?1561601585) Double-check you have the right wires connected to the right location, it can be tough to keep track of header pins as there are forty of them! After wiring, we recommend running I2C detection with `sudo i2cdetect -r -y 0` to verify that you see the device, in this case its address  **77** ![](https://cdn-learn.adafruit.com/assets/assets/000/077/547/medium800/sensors_i2cdevices_small.png?1561606288) # Install the CircuitPython BME280 Library OK onto the good stuff, you can now install the Adafruit BME280 CircuitPython library. As of this writing, not _all_ libraries are up on PyPI so you may want to search before trying to install. Look for  **circuitpython**  and then the driver you want. ![](https://cdn-learn.adafruit.com/assets/assets/000/076/929/medium800/linux_sensors_search.png?1560290687) (If you don't see it [you can open up a github issue on circuitpython to remind us](https://github.com/adafruit/circuitpython)!) Once you know the name, install it with `sudo pip3 install adafruit-circuitpython-bme280` ![](https://cdn-learn.adafruit.com/assets/assets/000/077/544/medium800/sensors_bme280-install.png?1561605897) You'll notice we also installed a _dependancy_ called **adafruit-circuitpython-busdevice**. This is a great thing about pip, if you have other required libraries they'll get installed too! We also recommend an adafruit-blinka update in case we've fixed bugs: `sudo pip3 install --upgrade adafruit_blinka` ## Run that code! The finish line is right up ahead. You can now run one of the (many in some cases) example scripts we've written for you. Check out the examples for your library by visiting the repository for the library and looking in the example folder. In this case, it would be [https://github.com/adafruit/Adafruit\_CircuitPython\_BME280/tree/master/examples](https://github.com/adafruit/Adafruit_CircuitPython_BME280/tree/master/examples) As of this writing there's only two examples. Here's the first one: ```auto import time import board import busio import adafruit_bme280 # Create library object using our Bus I2C port i2c = busio.I2C(board.SCLK, board.SDA) bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c) # OR create library object using our Bus SPI port #spi = busio.SPI(board.SCK, board.MOSI, board.MISO) #bme_cs = digitalio.DigitalInOut(board.D10) #bme280 = adafruit_bme280.Adafruit_BME280_SPI(spi, bme_cs) # change this to match the location's pressure (hPa) at sea level bme280.sea_level_pressure = 1013.25 while True: print("\nTemperature: %0.1f C" % bme280.temperature) print("Humidity: %0.1f %%" % bme280.humidity) print("Pressure: %0.1f hPa" % bme280.pressure) print("Altitude = %0.2f meters" % bme280.altitude) time.sleep(2) ``` Save this code to your DragonBoard by copying and pasting it into a text file, downloading it directly from the DragonBoard, etc. Then in your command line run `sudo python3 bme280_simpletest.py` ![](https://cdn-learn.adafruit.com/assets/assets/000/077/545/medium800/sensors_bme280_simpletest.png?1561606023) The code will loop with the sensor data until you quit with a Control-C Here's the second example: ```auto """ Example showing how the BME280 library can be used to set the various parameters supported by the sensor. Refer to the BME280 datasheet to understand what these parameters do """ import time import board import busio import adafruit_bme280 # Create library object using our Bus I2C port i2c = busio.I2C(board.SCLK, board.SDA) bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c) # OR create library object using our Bus SPI port #spi = busio.SPI(board.SCK, board.MOSI, board.MISO) #bme_cs = digitalio.DigitalInOut(board.D10) #bme280 = adafruit_bme280.Adafruit_BME280_SPI(spi, bme_cs) # change this to match the location's pressure (hPa) at sea level bme280.sea_level_pressure = 1013.25 bme280.mode = adafruit_bme280.MODE_NORMAL bme280.standby_period = adafruit_bme280.STANDBY_TC_500 bme280.iir_filter = adafruit_bme280.IIR_FILTER_X16 bme280.overscan_pressure = adafruit_bme280.OVERSCAN_X16 bme280.overscan_humidity = adafruit_bme280.OVERSCAN_X1 bme280.overscan_temperature = adafruit_bme280.OVERSCAN_X2 #The sensor will need a moment to gather inital readings time.sleep(1) while True: print("\nTemperature: %0.1f C" % bme280.temperature) print("Humidity: %0.1f %%" % bme280.humidity) print("Pressure: %0.1f hPa" % bme280.pressure) print("Altitude = %0.2f meters" % bme280.altitude) time.sleep(2) ``` Save this code to your DragonBoard by copying and pasting it into a text file, downloading it directly from the DragonBoard, etc. Then in your command line run `sudo python3 bme280_normal_mode.py` ![](https://cdn-learn.adafruit.com/assets/assets/000/077/546/medium800/sensors_bme280_normal.png?1561606207) The code will loop with the sensor data until you quit with a Control-C That's it! Now if you want to read the documentation on the library, what each function does in depth, visit our readthedocs documentation at [https://circuitpython.readthedocs.io/projects/bme280/en/latest/](https://circuitpython.readthedocs.io/projects/bme280/en/latest/) # CircuitPython Libraries on Linux and the 96Boards DragonBoard 410c ## SPI Sensors & Devices SPI is less popular than I2C but still you'll see lots of sensors and chips use it. Unlike I2C, you don't have everything share two wires. Instead, there's three shared wires ( **clock** , **data in** , **data out** ) and then a unique ' **chip select**' line for each chip. The nice thing about SPI is you can have as many chips as you like, even the same kind, all share the three SPI wires, as long as each one has a unique chip select pin. The formal/technical names for the 4 pins used are: - SPI clock - called **SCLK** , **SCK** or **CLK** - SPI data out - called **MOSI** for **M** icrocontroller **O** ut **S** erial **I** n. This is the wire that takes data _from_ the Linux computer _to_ the sensor/chip. Sometimes marked **SDI** or **DI** on chips - SPI data in - called **MISO** for **M** icrocontroller **I** n **S** erial **O** ut **.** This is the wire that takes data _to_ the Linux computer _from_ the sensor/chip. Sometimes marked **SDO** or **DO** on chips - SPI chip select - called **CS** or **CE** Remember, connect all SCK, MOSI and MISO pins together (unless there's some specific reason/instruction not to) and a unique CS pin for each device. Danger: SPI on microcontrollers is fairly simple, you have an SPI peripheral and you can transfer data on it with some low level command. Its 'your job' as a programmer to control the CS lines with a GPIO. That's how CircuitPython is structured as well. `busio` does just the SPI transmit/receive part and `busdevice` handles the chip select pin as well. Linux, on the other hand, doesn't let you send data to SPI without a CS line, and the CS lines are fixed in hardware as well. For example on the DragonBoard 410c, there's only one CS pin available for the hardware SPI pins - **SPI\_CS**  - and you _have_ to use it. (In theory there's an ioctl option called `no_cs` but this does not actually work) The upshot here is - to let you use more than 1 peripheral on SPI, we decided to **let you use any CS pins** you like, CircuitPython will toggle it the way you expect. But when we transfer SPI data we always tell the kernel to use **SPI\_CS**.  **SPI\_CS** will toggle like a CS pin, but if we leave it disconnected, its no big deal **The upshot here is basically never connect anything to **** SPI\_CS **. Use whatever chip select pin you define in CircuitPython and just leave the** CS** pin alone, it will toggle as if it is the chip select line, completely on its own, so you shouldn't try to use it as a digital input/output/whatever. Warning: ## Parts Used OK now that we've gone thru the warning, let's wire up an SPI MAX31855 thermocouple sensor, this particular device doesn't have a MOSI pin so we'll not connect it. Featured ### Thermocouple Amplifier MAX31855 breakout board (MAX6675 upgrade) [Thermocouple Amplifier MAX31855 breakout board (MAX6675 upgrade)](https://www.adafruit.com/product/269) Thermocouples are very sensitive, requiring a good amplifier with a cold-compensation reference. The MAX31855K does everything for you, and can be easily interfaced with any microcontroller, even one without an analog input. This breakout board has the chip itself, a 3.3V regulator with 10uF... In Stock [Buy Now](https://www.adafruit.com/product/269) [Related Guides to the Product](https://learn.adafruit.com/products/269/guides) ![Angled shot of black, square-shaped thermocouple breakout board with a green 2-pin terminal block.](https://cdn-shop.adafruit.com/640x480/269-06.jpg) Featured ### Thermocouple Type-K Glass Braid Insulated [Thermocouple Type-K Glass Braid Insulated](https://www.adafruit.com/product/270) Thermocouples are best used for measuring temperatures that can go above 100 °C. This is a bare wires bead-probe which can measure air or surface temperatures. Most inexpensive thermocouples have a vinyl covering which can melt at around 200 °C, this one uses a fiberglass braid so it... In Stock [Buy Now](https://www.adafruit.com/product/270) [Related Guides to the Product](https://learn.adafruit.com/products/270/guides) ![Angled shot of a Thermocouple Type-K Glass Braid Insulated wire. ](https://cdn-shop.adafruit.com/640x480/270-02.jpg) Because the DragonBoard 410c uses 1.8V logic levels, you will need a logic level converter to interface with most peripherals. Featured ### 4-channel I2C-safe Bi-directional Logic Level Converter [4-channel I2C-safe Bi-directional Logic Level Converter](https://www.adafruit.com/product/757) Because the Arduino (and Basic Stamp) are 5V devices, and most modern sensors, displays, flashcards, and modes are 3.3V-only, many makers find that they need to perform level shifting/conversion to protect the 3.3V device from 5V. Here we've got a ** 4-channel I2C-safe...** In Stock [Buy Now](https://www.adafruit.com/product/757) [Related Guides to the Product](https://learn.adafruit.com/products/757/guides) ![Angled shot of a 4-channel I2C-safe Bi-directional Logic Level Converter.](https://cdn-shop.adafruit.com/640x480/757-06.jpg) We recommend using a breadboard and some male-male wires. Featured ### Premium Male/Male Jumper Wires - 40 x 6" (150mm) [Premium Male/Male Jumper Wires - 40 x 6" (150mm)](https://www.adafruit.com/product/758) Handy for making wire harnesses or jumpering between headers on PCB's. These premium jumper wires are 6" (150mm) long and come in a 'strip' of 40 (4 pieces of each of ten rainbow colors). They have 0.1" male header contacts on either end and fit cleanly next to each other... Out of Stock [Buy Now](https://www.adafruit.com/product/758) [Related Guides to the Product](https://learn.adafruit.com/products/758/guides) ![Angled shot of Premium Male/Male Jumper Wires - 40 x 6 (150mm)](https://cdn-shop.adafruit.com/640x480/758-04.jpg) Featured ### Half Sized Premium Breadboard - 400 Tie Points [Half Sized Premium Breadboard - 400 Tie Points](https://www.adafruit.com/product/64) This is a cute, half-size breadboard with 400 tie points, good for small projects. It's 3.25" x 2.2" / 8.3cm x 5.5cm with a standard double-strip in the middle and two power rails on both sides. You can pull the power rails off easily to make the breadboard as... In Stock [Buy Now](https://www.adafruit.com/product/64) [Related Guides to the Product](https://learn.adafruit.com/products/64/guides) ![Angled shot of half-size solderless breadboard with red and black power lines.](https://cdn-shop.adafruit.com/640x480/64-06.jpg) # Wiring - Connect the DragonBoard  **Ground** pin to the **blue ground rail** on the breadboard - Connect the DragonBoard  **+5V** pin to the **red 5V rail** on the breadboard. - Connect the DragonBoard **+1.8V** pin to the **LV pin** on the Logic Level Converter - Connect the  **HV pin** on the Logic Level Converter to the MAX3185 **3Vo** - Connect the **Ground pin**  on the Logic Level Converter to the  **blue ground rail**  on the breadboard  - Connect the **Vin pin**  on the MAX31855 to the **red 5V rail ** on the breadboard  - Connect the **Ground pin**  on the MAX31855 to the  **blue ground rail**  on the breadboard  - Connect the  **B1 pin**  on the Logic Level Converter to the MAX31855 **DO** - Connect the  **B2 pin**  on the Logic Level Converter to the MAX31855 **CS** - Connect the  **B3 pin**  on the Logic Level Converter to the MAX31855 **CLK** - Connect the DragonBoard **SPI MISO**  to the  **A1 pin**  on the Logic Level Converter - Connect the DragonBoard  **GPIO 12**  to the  **A2 pin**  on the Logic Level Converter - Connect the DragonBoard  **SPI CLK**  to the  **A3 pin**  on the Logic Level Converter Danger: ![](https://cdn-learn.adafruit.com/assets/assets/000/077/628/medium800/sensors_spi_logic_converter_bb.png?1561781092) [spi_logic_converter.fzz](https://cdn-learn.adafruit.com/assets/assets/000/077/629/original/spi_logic_converter.fzz?1561781108) Double-check you have the right wires connected to the right location, it can be tough to keep track of Header pins as there are forty of them! ## Install the CircuitPython MAX31855 Library OK onto the good stuff, you can now install the Adafruit MAX31855 CircuitPython library. As of this writing, not _all_ libraries are up on PyPI so you may want to search before trying to install. Look for **circuitpython** and then the driver you want. ![](https://cdn-learn.adafruit.com/assets/assets/000/066/928/medium800/linux_sensors_max.png?1543722770) (If you don't see it [you can open up a github issue on circuitpython to remind us](https://github.com/adafruit/circuitpython)!) Once you know the name, install it with `sudo pip3 install adafruit-circuitpython-max31855` ![](https://cdn-learn.adafruit.com/assets/assets/000/077/549/medium800/sensors_spilib_install.png?1561610722) You'll notice we also installed a few other _dependancies_ called **spidev** , **adafruit-pureio** , **adafruit-circuitpython-busdevice** and more. This is a great thing about pip, if you have other required libraries they'll get installed too! We also recommend an adafruit-blinka update in case we've fixed bugs: `sudo pip3 install --upgrade adafruit_blinka` ## Run that code! The finish line is right up ahead. You can now run one of the (many in some cases) example scripts we've written for you. Check out the examples for your library by visiting the repository for the library and looking in the example folder. In this case, it would be [https://github.com/adafruit/Adafruit\_CircuitPython\_MAX31855/tree/master/examples](https://github.com/adafruit/Adafruit_CircuitPython_MAX31855/tree/master/examples) As of this writing there's only one example. But that's cool, here it is: https://github.com/adafruit/Adafruit_CircuitPython_MAX31855/blob/main/examples/max31855_simpletest.py Save this code to your DragonBoard by copying and pasting it into a text file, downloading it directly from the Pi, etc. Change the line that says `cs = digitalio.DigitalInOut(board.D5)` to `cs = digitalio.DigitalInOut(board.GPIO_12)` Then in your command line run `sudo python3 max31855_simpletest.py` ![](https://cdn-learn.adafruit.com/assets/assets/000/066/930/medium800/linux_sensors_maxtest.png?1543724762) The code will loop with the sensor data until you quit with a Control-C Warning: ![](https://cdn-learn.adafruit.com/assets/assets/000/066/931/medium800/linux_sensors_maxtest.png?1543724777) That's it! Now if you want to read the documentation on the library, what each function does in depth, visit our readthedocs documentation at [https://circuitpython.readthedocs.io/projects/max31855/en/latest/](https://circuitpython.readthedocs.io/projects/max31855/en/latest/) # CircuitPython Libraries on Linux and the 96Boards DragonBoard 410c ## UART / Serial After I2C and SPI, the third most popular "bus" protocol used is serial (also sometimes referred to as 'UART'). This is a non-shared two-wire protocol with an RX line, a TX line and a fixed baudrate. The most common devices that use UART are GPS units, MIDI interfaces, fingerprint sensors, thermal printers, and a scattering of sensors. One thing you'll notice fast is that most Linux computers have minimal UARTs, often only 1 hardware port. And that hardware port may be shared with a console. There are two ways to connect UART / Serial devices to your DragonBoard. The easy way, and the hard way. We'll demonstrate wiring up & using an Ultimate GPS with both methods. Featured ### Adafruit Ultimate GPS Breakout - 66 channel w/10 Hz updates [Adafruit Ultimate GPS Breakout - 66 channel w/10 Hz updates](https://www.adafruit.com/product/746) We carry a few different GPS modules here in the Adafruit shop, but none that satisfied our every desire - that's why we designed this little GPS breakout board. We believe this is the **Ultimate** GPS module, so we named it that. It's got everything you want and... In Stock [Buy Now](https://www.adafruit.com/product/746) [Related Guides to the Product](https://learn.adafruit.com/products/746/guides) ![Angled shot of GPS module breakout.](https://cdn-shop.adafruit.com/640x480/746-11.jpg) ## The Easy Way - An External USB-Serial Converter By far the easiest way to add a serial port is to use a USB to serial converter cable or breakout. They're not expensive, and you simply plug it into the USB port. On the other end are wires or pins that provide power, ground, RX, TX and maybe some other control pads or extras. Here are some options, they have varying chipsets and physical designs but all will do the job. We'll list them in order of recommendation. The first cable is easy to use and even has little plugs that you can arrange however you like, it contains a CP2102 Featured ### USB to TTL Serial Cable - Debug / Console Cable for Raspberry Pi [USB to TTL Serial Cable - Debug / Console Cable for Raspberry Pi](https://www.adafruit.com/product/954) The cable is easiest way ever to connect to your microcontroller/Raspberry Pi/WiFi router serial console port. Inside the big USB plug is a USB\<-\>Serial conversion chip and at the end of the 36" cable are four wire - red power, black ground, white RX into USB port, and green TX out... In Stock [Buy Now](https://www.adafruit.com/product/954) [Related Guides to the Product](https://learn.adafruit.com/products/954/guides) ![USB to TTL Serial Cable With Type A plug and 4 wire sockets](https://cdn-shop.adafruit.com/640x480/954-02.jpg) The CP2104 Friend is low cost, easy to use, but requires a little soldering, it has an '6-pin FTDI compatible' connector on the end, but all pins are broken out the sides. Both the FTDI friend and cable use classic FTDI chips, these are more expensive than the CP2104 or PL2303 but sometimes people like them! Featured ### FTDI Friend with Micro USB Port + extras [FTDI Friend with Micro USB Port + extras](https://www.adafruit.com/product/284) Long gone are the days of parallel ports and serial ports. Now the USB port reigns supreme! But USB is hard, and you just want to transfer your every-day serial data from a microcontroller to computer. What now? Enter the FTDI Friend! The FTDI Friend is a tweaked out FTDI FT232RL chip... In Stock [Buy Now](https://www.adafruit.com/product/284) [Related Guides to the Product](https://learn.adafruit.com/products/284/guides) ![Angled shot of blue rectangular FTDI breakout board.](https://cdn-shop.adafruit.com/640x480/284-03.jpg) Featured ### FTDI Serial TTL-232 USB Cable [FTDI Serial TTL-232 USB Cable](https://www.adafruit.com/product/70) Just about all electronics use TTL serial for debugging, bootloading, programming, serial output, etc. But it's rare for a computer to have a serial port anymore. This is a USB to TTL serial cable, with a FTDI FT232RL usb/serial chip embedded in the head. It has a 6-pin socket at the end... In Stock [Buy Now](https://www.adafruit.com/product/70) [Related Guides to the Product](https://learn.adafruit.com/products/70/guides) ![Coiled FTDI Serial TTL-232 USB Cable. ](https://cdn-shop.adafruit.com/640x480/70-03.jpg) There is also a GPS module with integrated serial available which works like the GPS breakout connected to the USB to TTL Serial cable. Featured ### Adafruit Ultimate GPS GNSS with USB - 99 channel w/10 Hz updates [Adafruit Ultimate GPS GNSS with USB - 99 channel w/10 Hz updates](https://www.adafruit.com/product/4279) The Ultimate GPS module you know and love has a _glow-up_ to let it be easily used with any computer, not just microcontrollers! With the built-in USB-to-Serial converter, you can now plug-n-play the Ultimate GPS into your computer, laptop, embedded Linux computer, and more. Power and... In Stock [Buy Now](https://www.adafruit.com/product/4279) [Related Guides to the Product](https://learn.adafruit.com/products/4279/guides) ![Angled shot of GPS breakout board.](https://cdn-shop.adafruit.com/640x480/4279-05.jpg) You can wire up the GPS by connecting the following - **GPS Vin**   to **USB** **5V** or **3V** (red wire on USB console cable) - **GPS Ground** to **USB Ground** (black wire) - **GPS RX** to **USB TX** (green wire) - **GPS TX** to **USB RX** (white wire) ![](https://cdn-learn.adafruit.com/assets/assets/000/076/962/medium800/linux_sensors_usbgps_bb.png?1560366327) Once the USB adapter is plugged in, you'll need to figure out what the serial port name is. You can figure it out by unplugging-replugging in the USB and then typing `dmesg | tail -10` (or just `dmesg`) and looking for text like this: ![](https://cdn-learn.adafruit.com/assets/assets/000/077/007/medium800/sensors_dmesg_out.png?1560450692) At the bottom, you'll see the 'name' of the attached device, in this case its `ttyUSB0`, that means our serial port device is available at `/dev/ttyUSB0` ## The Hard Way - Using Built-in UART If you don't want to plug in external hardware to the DragonBoard you _can_ use the built in UART on the RX/TX pins. Unlike the Raspberry Pi, the DragonBoard isn't using the RX/TX pins for a console, those are on a different UART peripheral, so you should be good to go! You can use the built in UART via `/dev/ttyMSM1` Wire the GPS as follows: - Connect the DragonBoard  **Ground** pin to the **blue ground rail** on the breadboard - Connect the DragonBoard  **+5V** pin to the **red 5V rail** on the breadboard. - Connect the DragonBoard **+1.8V** pin to the **LV pin** on the Logic Level Converter - Connect the  **HV pin** on the Logic Level Converter to the  **red **** 5V rail** - Connect the **Ground pin**  on the Logic Level Converter to the  **blue ground rail**  on the breadboard  - Connect the **Vin pin**  on the GPS to the **red 5V rail ** on the breadboard  - Connect the **Ground pin**  on the GPS to the  **blue ground rail**  on the breadboard  - Connect the  **B1 pin**  on the Logic Level Converter to the GPS  **RX pin** - Connect the  **B2 pin**  on the Logic Level Converter to the GPS  **TX pin** - Connect the DragonBoard **UART0 TX**  to the  **A1 pin**  on the Logic Level Converter - Connect the DragonBoard  **UART0 RX**  to the  **A2 pin**  on the Logic Level Converter Danger: ![](https://cdn-learn.adafruit.com/assets/assets/000/077/551/medium800/sensors_uart_gps_logic_converter_bb.png?1561612384) [uart_gps_logic_converter.fzz](https://cdn-learn.adafruit.com/assets/assets/000/077/552/original/uart_gps_logic_converter.fzz?1561612593) ## Install the CircuitPython GPS Library OK onto the good stuff, you can now install the Adafruit GPS CircuitPython library. As of this writing, not _all_ libraries are up on PyPI so you may want to search before trying to install. Look for **circuitpython** and then the driver you want. ![](https://cdn-learn.adafruit.com/assets/assets/000/076/965/medium800/linux_sensors_image.png?1560366837) (If you don't see it [you can open up a github issue on circuitpython to remind us](https://github.com/adafruit/circuitpython)!) Once you know the name, install it with `sudo pip3 install pyserial adafruit-circuitpython-gps` You'll notice we also installed a _dependancy_ called **pyserial**. This is a great thing about pip, if you have other required libraries they'll get installed too! We also recommend an adafruit-blinka update in case we've fixed bugs: `sudo pip3 install --upgrade adafruit_blinka` ## Run that code! The finish line is right up ahead. You can now run one of the (many in some cases) example scripts we've written for you. Check out the examples for your library by visiting the repository for the library and looking in the example folder. In this case, it would be [https://github.com/adafruit/Adafruit\_CircuitPython\_GPS/tree/master/examples](https://github.com/adafruit/Adafruit_CircuitPython_GPS/tree/master/examples) Lets start with the simplest, the echo example: https://github.com/adafruit/Adafruit_CircuitPython_GPS/blob/main/examples/gps_echotest.py **We'll need to configure this code to work with our UART port name.** - If you're using a USB-to-serial converter, the device name is _probably_ `/dev/ttyUSB0` - but check `dmesg` to make sure. - If you're using the built-in UART on the DragonBoard, the device name is `/dev/ttyMSM1`. Comment out the lines that reference `board.TX`, `board.RX` and `busio.uart` and uncomment the lines that `import serial` and define the `serial` device, like so: ```auto # Define RX and TX pins for the board's serial port connected to the GPS. # These are the defaults you should use for the GPS FeatherWing. # For other boards set RX = GPS module TX, and TX = GPS module RX pins. #RX = board.RX #TX = board.TX # Create a serial connection for the GPS connection using default speed and # a slightly higher timeout (GPS modules typically update once a second). #uart = busio.UART(TX, RX, baudrate=9600, timeout=3000) # for a computer, use the pyserial library for uart access import serial uart = serial.Serial("/dev/ttyUSB0", baudrate=9600, timeout=3000) ``` And update the `"/dev/ttyUSB0"` device name if necessary to match your USB interface. Whichever method you use, you should see output like this, with **$GP**"NMEA sentences" - there probably wont be actual location data because you haven't gotten a GPS fix. As long as you see those **$GP** strings sorta like the below, you've got it working! ![](https://cdn-learn.adafruit.com/assets/assets/000/077/553/medium800/sensors_gps_output.png?1561614050) # CircuitPython Libraries on Linux and the 96Boards DragonBoard 410c ## More To Come! That's just a taste of what we've got working so far We're adding more support constantly, so please hold tight and [visit the adafruit\_blinka github repo](https://github.com/adafruit/Adafruit_Blinka) to share your feedback and perhaps even submit some improvements! If you'd like to contribute, but aren't sure where to start, check out the following guides: - [Adding a Single Board Computer to PlatformDetect for Blinka](https://learn.adafruit.com/adding-a-single-board-computer-to-platformdetect-for-blinka) - [Adding a Single Board Computer to Blinka](https://learn.adafruit.com/adding-a-single-board-computer-to-blinka) # CircuitPython Libraries on Linux and the 96Boards DragonBoard 410c ## FAQ & Troubleshooting There's a few oddities when running Blinka/CircuitPython on Linux. Here's a list of stuff to watch for that we know of! This FAQ covers all the various platforms and hardware setups you can run Blinka on. Therefore, some of the information may not apply to your specific setup. ## Update Blinka/Platform Libraries **Most issues can be solved by forcing Python to upgrade to the latest `blinka` / `platform-detect` libraries**. Try running `sudo python3 -m pip install --upgrade --force-reinstall adafruit-blinka Adafruit-PlatformDetect` ### Getting an error message about 'board' not found or 'board' has no attribute Somehow you have ended up with either the wrong  **board**  module or no  **board**  module at all. **DO NOT**  try to fix this by manually installing a library named `board`. There is [one out there](https://pypi.org/project/board/) and it has nothing to do with Blinka. You will break things if you install that library! The easiest way to recover is to simply force a reinstall of Blinka with: `python3 -m pip install --upgrade --force-reinstall adafruit-blinka` Additionally, and especially if you are using a more recent version of Python, you may run into this error if you either do not have a Virtual Environment active or setup. See the [Python Virtual Environment Usage on Raspberry Pi](https://learn.adafruit.com/python-virtual-environment-usage-on-raspberry-pi) guide for more information or check out the guide's Installation page. ### Mixed SPI mode devices Due to the way we share an SPI peripheral, you cannot have two SPI devices with different 'mode/polarity' on the same SPI bus - you'll get weird data 95% of SPI devices are mode 0, check the driver to see mode or polarity settings. For example: - [LSM9DS1 is mode 1](https://github.com/adafruit/Adafruit_CircuitPython_LSM9DS1/blob/master/adafruit_lsm9ds1.py#L408), please use in I2C mode instead of SPI - [MAX31865 is phase 1](https://github.com/adafruit/Adafruit_CircuitPython_MAX31865/blob/master/adafruit_max31865.py#L97), try using this on a separate SPI device, or read data twice. ### Why am I getting AttributeError: 'SpiDev' object has no attribute 'writebytes2'? This is due to having an older version of [spidev](https://pypi.org/project/spidev/). You need at least version 3.4. This should have been [taken care of](https://github.com/adafruit/Adafruit_Blinka/blob/8a4686cbc7ebd7f338f64517fa42db4dc5b5c78c/requirements.txt#L6) when you installed Blinka, but in some cases it does not seem to happen. To check what version of spidev Python is using: > `$ python3` > `Python 3.6.8 (default, Oct 7 2019, 12:59:55) ` > `[GCC 8.3.0] on linux` > `Type "help", "copyright", "credits" or "license" for more information.` > `>>> import spidev` > `>>> spidev. __version__ ` > `'3.4'` > `>>>` If you see a version lower then 3.4 reported, then try a force upgrade of spidev with (back at command line): `sudo python3 -m pip install --upgrade --force-reinstall spidev` ### No Pullup/Pulldown support on some Linux boards or MCP2221 Some Linux boards, for example, AllWinner-based, do not have support to set pull up or pull down on their GPIO. Use an external resistor instead! ### Getting OSError: read error with MCP2221 If you are getting a stack trace that ends with something like: > `return self._hid.read(64)` > `File "hid.pyx", line 122, in hid.device.read` > `OSError: read error` Try setting an environment variable named **BLINKA\_MCP2221\_RESET\_DELAY** to a value of **0.5 or higher**. Windows: `set BLINKA_MCP2221_RESET_DELAY=0.5` Linux: `export BLINKA_MCP2221_RESET_DELAY=0.5` This is a value in seconds to wait between resetting the MCP2221 and the attempt to reopen it. The reset is seen by the operating system as a hardware disconnect/reconnect. Different operating systems can need different amounts of time to wait after the reconnect before the attempt to reopen. Setting the above environment variable will override the default reset delay time, allowing it to be increased as needed for different setups. ### Using FT232H with other FTDI devices. Blinka uses the libusbk driver to talk to the FT232H directly. If you have other FTDI devices installed that are using the FTDI VCP drivers, you may run into issues. See here for a possible workaround: [https://forums.adafruit.com/viewtopic.php?f=19&t=166999](https://forums.adafruit.com/viewtopic.php?f=19&t=166999) ### Getting This is probably only an issue for older versions of Windows. If you run into something like this, see this issue thread: [https://github.com/pyusb/pyusb/issues/120](https://github.com/pyusb/pyusb/issues/120) which describes copying the 32bit and 64bit DLLs into specific folders. ([example for Win7](https://github.com/pyusb/pyusb/issues/120#issuecomment-322058585)) ### Getting Check out this issue thread: [https://github.com/pyusb/pyusb/issues/355](https://github.com/pyusb/pyusb/issues/355 "https://github.com/pyusb/pyusb/issues/355") which has **lots** of discussion. It is probably worth reading through it all to determine what applies for your setup.  Most solutions seem to rely on setting the **DYLD\_LIBRARY\_PATH** environment variable. This issue thread has further information: [https://github.com/orgs/Homebrew/discussions/3424](https://github.com/orgs/Homebrew/discussions/3424) ### I can't get neopixel, analogio, audioio, rotaryio, displayio or pulseio to work! Some CircuitPython modules like may not be supported. - Most SBCs do not have analog inputs so there is no `analogio` - Few SBCs have `neopixel` support so that is only available on Raspberry Pi (and any others that have low level neopixel protocol writing - Rotary encoders (`rotaryio`) is handled by interrupts on microcontrollers, and is not supported on SBCs at this time - Likewise `pulseio` PWM support is not supported on many SBCs, and if it is, it will not support a carrier wave (Infrared transmission) - For display usage, we suggest using python `Pillow` library or `Pygame`, we do not have `displayio` support We aim to have, at a minimum, `digitalio` and `busio` (I2C/SPI). This lets you use the vast number of driver libraries For analog inputs,[the MCP3xxx library](https://github.com/adafruit/Adafruit_CircuitPython_MCP3xxx) will give you `AnalogIn` objects. For PWM outputs, [try the PCA9685](https://github.com/adafruit/Adafruit_CircuitPython_PCA9685). For audio, use pygame or other Python3 libraries to play audio. Some libraries, like [Adafruit\_CircuitPython\_DHT](https://github.com/adafruit/Adafruit_CircuitPython_DHT) will try to bit-bang if pulsein isn't available. Slow linux boards (\<700MHz) may not be able to read the pins fast enough), you'll just have to try! ### Help, I'm getting the message It looks like **libgpiod** may not be installed on your board. Try running the command: `sudo apt-get install libgpiod2` ### = v5.5.0 Be sure you have the latest libgpiod.py script and run it with the `-l` or `--legacy` flag: `sudo python3 libgpiod.py --legacy` All Raspberry Pi Computers Have: - 1 x I2C port with **busio** (but clock stretching is not supported in hardware, so you must set the I2C bus speed to 10KHz to 'fix it') - 2 x SPI ports with **busio** - 1 x UART port with **serial** - note this is shared with the hardware console - **pulseio.pulseIn** using gpiod - **neopixel** support on a few pins - No AnalogIn support (Use an MCP3008 or similar to add ADC) - No PWM support (Use a PCA9685 or similar to add PWM) ![sensors_raspberry_pi.jpg](https://cdn-learn.adafruit.com/assets/assets/000/077/099/medium640/sensors_raspberry_pi.jpg?1560709288) Google Coral TPU Dev Boards Have: - 1 x I2C port with **busio** - 1 x SPI ports with **busio** - 1 x UART port with **serial** - note this is shared with the hardware console - 3 x PWMOut support - No NeoPixel support - No AnalogIn support (Use an MCP3008 or similar to add ADC) ![sensors_google_coral.jpg](https://cdn-learn.adafruit.com/assets/assets/000/077/100/medium640/sensors_google_coral.jpg?1560709528) Orange Pi PC Plus Boards Have: - 1 x I2C port with **busio** - 1 x SPI ports with **busio** - 1 x UART port with **serial** - No NeoPixel support - No AnalogIn support (Use an MCP3008 or similar to add ADC) - No PWM support (Use a PCA9685 or similar to add PWM) ![sensors_47688275371_ab6f25d2f2_k.jpg](https://cdn-learn.adafruit.com/assets/assets/000/077/102/medium640/sensors_47688275371_ab6f25d2f2_k.jpg?1560709858) Orange Pi R1 Boards Have: - 1 x I2C port with **busio** - 1 x SPI port with **busio** - 1 x UART port with **serial** - No NeoPixel support - No AnalogIn support (Use an MCP3008 or similar to add ADC) - No PWM support (Use a PCA9685 or similar to add PWM) ![sensors_orange_pi_r1.jpg](https://cdn-learn.adafruit.com/assets/assets/000/077/105/medium640/sensors_orange_pi_r1.jpg?1560710441) ODROID C2 Boards Have: - 1 x I2C port with  **busio** - No SPI support - 1 x UART port with **serial** - note this is shared with the hardware console - No NeoPixel support - No AnalogIn support (Use an MCP3008 or similar to add ADC) - No PWM support (Use a PCA9685 or similar to add PWM) ![sensors_product.jpg](https://cdn-learn.adafruit.com/assets/assets/000/077/107/medium640/sensors_product.jpg?1560710758) DragonBoard 410c Boards Have: - 2 x I2C port with  **busio** - 1 x SPI port with  **busio** - 1 x UART port with  **serial** - No NeoPixel support - No AnalogIn support (Use an MCP3008 or similar to add ADC) - No PWM support (Use a PCA9685 or similar to add PWM) ![sensors_dragonboard410c.jpg](https://cdn-learn.adafruit.com/assets/assets/000/077/714/medium640/sensors_dragonboard410c.jpg?1562085887) NVIDIA Jetson Nano Boards Have: - 2 x I2C port with  **busio** - 2 x SPI ports with **busio** - 2 x UART port with  **serial**  - note one of these is shared with the hardware console - No NeoPixel support - No AnalogIn support (Use an MCP3008 or similar to add ADC) - No PWM support (Use a PCA9685 or similar to add PWM) ![sensors_faq_troubleshooting.jpg](https://cdn-learn.adafruit.com/assets/assets/000/080/798/medium640/sensors_faq_troubleshooting.jpg?1568157791) FT232H Breakouts Have: - 1x I2C port **OR** SPI port with **busio** - 12x GPIO pins with **digitalio** - No UART - No AnalogIn support - No AnalogOut support - No PWM support If you are using [Blinka in FT232H mode](https://learn.adafruit.com/circuitpython-on-any-computer-with-ft232h), then keep in mind these basic limitations. - SPI and I2C can not be used at the same time since they share the same pins. - GPIO speed is not super fast, so trying to do arbitrary bit bang like things may run into speed issues. - There are no ADCs. - There are no DACs. - UART is not available (its a different FTDI mode) ![sensors_2264-04.jpg](https://cdn-learn.adafruit.com/assets/assets/000/081/745/medium640/sensors_2264-04.jpg?1569886041) MCP2221 Breakouts Have: - 1x I2C port with **busio** - 4x GPIO pins with **digitalio** - 3x AnalogIn with **analogio** - 1x AnalogOut with **analogio** - 1x UART with **pyserial** - No PWM support - No hardware SPI support If you are using Blinka in MCP2221 mode, then keep in mind these basic limitations. - GPIO speed is not super fast, so trying to do arbitrary bit bang like things may run into speed issues. - UART is available via `pyserial`, the serial COM port shows up as a second USB device during enumeration ![sensors_mcp2221_small_iso.jpg](https://cdn-learn.adafruit.com/assets/assets/000/086/115/medium640/sensors_mcp2221_small_iso.jpg?1576799406) ## Guide Products ### USB to TTL Serial Cable - Debug / Console Cable for Raspberry Pi [USB to TTL Serial Cable - Debug / Console Cable for Raspberry Pi](https://www.adafruit.com/product/954) The cable is easiest way ever to connect to your microcontroller/Raspberry Pi/WiFi router serial console port. Inside the big USB plug is a USB\<-\>Serial conversion chip and at the end of the 36" cable are four wire - red power, black ground, white RX into USB port, and green TX out... In Stock [Buy Now](https://www.adafruit.com/product/954) [Related Guides to the Product](https://learn.adafruit.com/products/954/guides) ### 4-channel I2C-safe Bi-directional Logic Level Converter [4-channel I2C-safe Bi-directional Logic Level Converter](https://www.adafruit.com/product/757) Because the Arduino (and Basic Stamp) are 5V devices, and most modern sensors, displays, flashcards, and modes are 3.3V-only, many makers find that they need to perform level shifting/conversion to protect the 3.3V device from 5V. Here we've got a ** 4-channel I2C-safe...** In Stock [Buy Now](https://www.adafruit.com/product/757) [Related Guides to the Product](https://learn.adafruit.com/products/757/guides) ### Half Sized Premium Breadboard - 400 Tie Points [Half Sized Premium Breadboard - 400 Tie Points](https://www.adafruit.com/product/64) This is a cute, half-size breadboard with 400 tie points, good for small projects. It's 3.25" x 2.2" / 8.3cm x 5.5cm with a standard double-strip in the middle and two power rails on both sides. You can pull the power rails off easily to make the breadboard as... In Stock [Buy Now](https://www.adafruit.com/product/64) [Related Guides to the Product](https://learn.adafruit.com/products/64/guides) ### USB 2.0 and Ethernet Hub - 3 USB Ports and 1 Ethernet [USB 2.0 and Ethernet Hub - 3 USB Ports and 1 Ethernet](https://www.adafruit.com/product/2909) One can never have enough socks or USB ports. Add some more USB and Ethernet capability to your Raspberry Pi or, really, any kind of computer with this **USB 2.0 and Ethernet Hub**! This handy combo-hub has 3 USB 2.0 ports and an AX88772A Ethernet transceiver. This... In Stock [Buy Now](https://www.adafruit.com/product/2909) [Related Guides to the Product](https://learn.adafruit.com/products/2909/guides) ### Diffused Blue 10mm LED (25 pack) [Diffused Blue 10mm LED (25 pack)](https://www.adafruit.com/product/847) Need some big indicators? We are big fans of these huge diffused blue LEDs. They are really bright so they can be seen in daytime, and from any angle. They go easily into a breadboard and will add that extra zing to your project. - Pack of 25 diffused blue LEDs - 10mm... No Longer Stocked [Buy Now](https://www.adafruit.com/product/847) [Related Guides to the Product](https://learn.adafruit.com/products/847/guides) ### Through-Hole Resistors - 470 ohm 5% 1/4W - Pack of 25 [Through-Hole Resistors - 470 ohm 5% 1/4W - Pack of 25](https://www.adafruit.com/product/2781) ΩMG! You're not going to be able to resist these handy resistor packs! Well, axially, they do all of the resisting for you! This is a **25 Pack of 470Ω Resistors.** More specifically, they are **carbon film** , through-hole... In Stock [Buy Now](https://www.adafruit.com/product/2781) [Related Guides to the Product](https://learn.adafruit.com/products/2781/guides) ### Tactile Switch Buttons (12mm square, 6mm tall) x 10 pack [Tactile Switch Buttons (12mm square, 6mm tall) x 10 pack](https://www.adafruit.com/product/1119) Medium-sized clicky momentary switches are standard input "buttons" on electronic projects. These work best in a PCB but [can be used on a solderless breadboard as shown in this tutorial](https://learn.adafruit.com/adafruit-arduino-lesson-6-digital-inputs?view=all). The... In Stock [Buy Now](https://www.adafruit.com/product/1119) [Related Guides to the Product](https://learn.adafruit.com/products/1119/guides) ### Premium Male/Male Jumper Wires - 40 x 6" (150mm) [Premium Male/Male Jumper Wires - 40 x 6" (150mm)](https://www.adafruit.com/product/758) Handy for making wire harnesses or jumpering between headers on PCB's. These premium jumper wires are 6" (150mm) long and come in a 'strip' of 40 (4 pieces of each of ten rainbow colors). They have 0.1" male header contacts on either end and fit cleanly next to each other... Out of Stock [Buy Now](https://www.adafruit.com/product/758) [Related Guides to the Product](https://learn.adafruit.com/products/758/guides) ## Related Guides - [Adafruit CP2104 and CP2102N Friend - USB to Serial Converter](https://learn.adafruit.com/adafruit-cp2102n-cp2104-friend-usb-to-serial-converter.md) - [LoRa and LoRaWAN Radio for Raspberry Pi](https://learn.adafruit.com/lora-and-lorawan-radio-for-raspberry-pi.md) - [LLM Agent Embodiment Kit](https://learn.adafruit.com/llm-agent-embodiment-kit.md) - [Feather Waveform Generator in CircuitPython](https://learn.adafruit.com/waveform-generator.md) - [Air Quality Sensor 3D Printed Enclosure](https://learn.adafruit.com/air-quality-sensor-silo-house.md) - [Adding a Single Board Computer to PlatformDetect for Blinka](https://learn.adafruit.com/adding-a-single-board-computer-to-platformdetect-for-blinka.md) - [Adafruit Feather HUZZAH ESP8266](https://learn.adafruit.com/adafruit-feather-huzzah-esp8266.md) - [Grand Central USB MIDI Controller in CircuitPython](https://learn.adafruit.com/grand-central-usb-midi-controller-in-circuitpython.md) - [Guardian Robot – Zelda BOTW](https://learn.adafruit.com/guardian-robot-zelda-botw.md) - [Circuit Playground Express Sugar Glider](https://learn.adafruit.com/cpx-sugar-glider.md) - [Adafruit IO Basics: Analog Input](https://learn.adafruit.com/adafruit-io-basics-analog-input.md) - [Adding a Single Board Computer to Blinka](https://learn.adafruit.com/adding-a-single-board-computer-to-blinka.md) - [Adafruit Metro ESP32-S3](https://learn.adafruit.com/adafruit-metro-esp32-s3.md) - [Breadboards for Beginners](https://learn.adafruit.com/breadboards-for-beginners.md) - [Circuit Playground Express Serial Communications](https://learn.adafruit.com/circuit-playground-express-serial-communications.md) - [3D Printed Case for Raspberry Pi Pico](https://learn.adafruit.com/raspberry-pi-pico-case.md)