The first Adafruit Show ‘n Tell of 2020

Joining Adafruit Show ‘n Tell with Helen Leigh was a fun way to start 2020!

Helen embroidered the CircuitPython-powered Serpente board from Arturo at Chaos Communication Congress (36c3):

I showed Linux running on a RISC-V core in the ECP5 FPGA on the Hackaday Supercon badge:

I gave a shout-out to Greg Davill who got Linux booting the OrangeCrab while at 36c3:


Greg’s open hardware OrangeCrab board features the ECP5 FPGA in an Adafruit Feather form factor and is capable of running a RISC-V “soft” core using LiteX.

Find out more about Linux on RISC-V using open source FPGA toolchains in the slides from my 36c3 talk

The first Adafruit Show ‘n Tell of 2020

KiCad teardop plugin and flexible PCBs

Screenshot from 2019-12-06 21-04-05

Thanks to Anool posting on Hackaday about KiCad plugins.  I decided to try out the Teardrop plugin by NilujePerchut:

Screenshot from 2019-12-11 14-51-09

KiCad Teardrop Plugin

This action plugin adds and deletes teardrops to a PCB.

This implementation uses zones instead of arcs. This allows to comply with DRC rules by simply rebuild all zones. You can also modify their shape by simply modifying the zone outline (like any other zone). Teardrops created with this script use a specific priority (0x4242) to be recognized as teardrops.

Here is the result of my first experiment to use the Teardrop plugin on a flexible PCB to reduce the mechanical stress of flexing the trace:

The board is available as an OSH Park shared project and the KiCad design files are on GitHub.

The author of the plugin was very responsive to GitHub issues and I was able to get better results on my next flex design which is currently being manufactured:

My flex “business card” will fold over a coin cell battery to light a 0603 LED.

Curious how the plugin works?  It creates zones next to the vias and pads.  Here are the two teardrop zones that connect traces to a via:

Warning: you need create a schematic and generate a netlist before starting the PCB layout.  Otherwise the the zones the plugin creates won’t be filled:

You also need to be careful that there is not copper on the same layer too close to the zone.  For example, the text was too close to the teardrop zone on this via, so I moved the text down and the zone now fills correctly:

An open GitHub issue is that the teardrop zone does not align perfectly for SMD pads that are not circles (like rectangles, squares, rounded rectangles).  The work around I used was to move the zone after it is filled to align with my SMD pad:

I hope you have fun with this plugin and leave a comment if you use it your own design!

UPDATE: I joined Adafruit Show-n-Tell to talk about flex PCBs and the teardrop plugin at 10 min 51 sec mark

KiCad teardop plugin and flexible PCBs

CircuitPython in a small factor with CircuitBrains Deluxe

Kevin Neubauer has designed a System-on-Module (SoM) to make it easy to embed Circuit Python in project:

CircuitBrains Deluxe

I love Adafruit’s CircuitPython product line. The ability to just plug your board into USB, make code changes, and see them take effect in real-time is amazing. However, when it comes to finishing up a CircuitPython project, I felt limited in choice for a small form-factor, streamlined board. I always ended up creating my own boards. The overhead in doing this was huge though. You have to make sure your design has proper power, decoupling, and clock. Then you source all of the parts. After that you lay out the PCB and have it fabricated. When the PCB and parts arrive, you have to deal with finicky small-pitch surface mount assembly. Finally, you need to download the sources for the UF2 bootloader and CircuitPython and define your board, compile, and flash. This makes what should be a small project pretty time consuming and tedious!


  1. Reduce barriers to entry for custom CircuitPython-based boards & badges
  2. Package CircuitPython into a small form-factor module that will add minimal dimensions to a parent project


  1. Dimensions: 29 x 29 x 3.5 millimeters / 1.15 x 1.15 x 0.15 inches
  2. Atmel ATSAMD51J19A Microcontroller (32-bit ARM Cortex M4)
    • 120 MHz
    • 192 KB SRAM
    • 512 KB Flash
  3. 8 MB SPI Flash
  4. Onboard 3.3V LDO Regulator
  5. Power and Status LEDs
  6. Breakouts for SPI and I2C
  7. Breakouts for 14 Analog and 19 Digital Inputs/Outputs


CircuitPython in a small factor with CircuitBrains Deluxe

The Open Book Feather e-reader

Joey Castillo has created an awesome open hardware reading device:


The Open Book Feather

The Open Book is an open-hardware device for reading books in all the languages of the world. It includes a large screen and buttons for navigation, as well as audio options for accessibility and ports to extend its functionality. Its detailed silkscreen, with the all the manic energy and quixotic ambition of a Dr. Bronner’s bottle, aims to demystify the Open Book’s own design, breaking down for the curious reader both how the book works, and how they can build one for themselves.


At the core of the Open Book is a SAMD51J19A microcontroller, a powerful ARM Cortex M4 with 512 KB of Flash and 192 KB of RAM. It has 51 pins of GPIO, and the Open Book uses all of them for peripherals and possibilities:

A 400×300 black and white e-paper screen enables the core experience of, y’know, reading.

A MicroSD slot allows for plenty of external storage for files. An offline copy of Wikipedia fits in 64 gigs — Hitchhiker’s Guide, anyone?

User input comes from seven buttons on a shift register, plus an eighth button tied directly to one of the SAMD51’s interrupt pins.

A dedicated flash chip for languages gives the book room to store glyphs and Unicode data for every language in the Basic Multilingual Plane (which is most of the languages in use today).

A 3.5mm audio jack

Screenshot from 2019-12-05 19-15-14.png

Joey (@josecastillo) did a demo of the the Open Book e-reader on Adafruit Show-n-Tell last night (jump to 15 min 59 sec):


The Open Book Feather e-reader

Make your own PCB with Eagle, OSH Park, and Adafruit

Bryan Siepert has published a new Adafruit guide on creating custom circuit boards with EAGLE:


Make your own PCB with Eagle, OSH Park, and Adafruit!

This guide will introduce you to the basic process I use to build PCBs based on Adafruit and other open source designs. We will extract parts of the board files as what Eagle calls “Design Blocks” and then we will use them along with a fundamental workflow in Eagle to create a featherwing-like board for the Trinket M0. This board will allow you to securely attach the Adafruit INA219 current sensor breakout to a Trinket without having to use jumper wires to connect them together. We’re starting with this modest goal to keep things simple as we learn some fundamental concepts, while hopefully also ending up with a useful circuit.

This guide will cover using a Trinket M0 and INA219 breakout, however these same methods can be used to make a PCB to replace the breadboard or protoboard. These techniques can be used to extract useful pieces from open source boards to use in your own completely new circuit boards.

Make your own PCB with Eagle, OSH Park, and Adafruit

#badgelife add-on adapter for Adafruit LED matrix


Adapter board to attach Adafruit 8×8 LED Matrix board as #badgelife add-on (using the DC26 SAO 2×2 pin header)

KiCad design files:

OSH Park shared project:

#badgelife add-on adapter for Adafruit 8×8 LED matrix

d68231e20e8a38d08579fd6c33f80553 (1)

Order from OSH Park

MicroPython support:



#badgelife add-on adapter for Adafruit LED matrix