Document breadboard builds by writing Python code

In my last post I mentioned that I was using breadboarder - a Python program that eases the pain of documenting breadboard-based projects.

You write a descriptiopn of your project using a Python-based DSL - a domain-specific language.

It lets you explain what wire or component to add to the breadboard, and where to connect it.

You write code like this:

And it generates markdown and png files which render like this:

It saves hours of layout, you can build complex projects out of simple ones, and everything is under source control.

I need to improve the documentation but breadboarder is on GitHub.

Fault-finding breadboarded circuits - a tale from the trenches

blobstar

Yesterday I destroyed an Atmel ATMega328 chip. (That's the chip at the heart of the Arduino.)

The Atmel chips are very well designed, and it's really hard to damage them, but I've managed it twice in the last decade. Yesterday's episode was due to a mistake in wiring up an Arduino clone that I've been building on a breadboard.

The clone is a descendant of Cefn Hoyle's excellent Shrimp design. I decided to build an alternative version which could be programmed using an FTDI cable and made permanent using an Adafruit perma-proto board.

The correct layout (shown above) is easy to follow, but my ageing eyes led me to connect two of the power wires to the wrong pins. When I powered up the board using an FTDI cable the LED didn't blink and I knew something was wrong.

But what?

A simple approach to problem-solving

When something stops working, you focus on what's changed. When you have two versions of something, only one of which works, you focus on the difference.

In my case I had a working version of the design on an Adafruit permo-proto board. When I compared the bread-boarded version with the board that worked I realised the mistake I'd made. I fixed the wiring and tried again.

The bread-boarded version still didn't work.

I rechecked the wiring and convinced myself that there were only minor differences between the bread-boarded and soldered versions. The bread-boarded version uses a crystal and I'd omitted a couple of tiny capacitors that aren't normally necessary, so I added them. Still no joy.

By now the only significant difference between the circuits was the physical chips.

I swapped the chip from the known-good board into the breadboard, powered it up, and...

Success

The board worked!

Here's the perma-proto version blinking as it should.

Clearly, my earlier wiring mistake had fried the ATMega chip.  Once I'd replaced it both versions worked.

I'm documenting the breadboard version for use in an updated version of my e-book Making the Shrimp. I'm using a neat piece of software called breadboarder.

Breadboarder lets you describe a circuit using a simple Python-based DSL (Domain Specific Language). It generates an SVG diagram and step-by-step instructions in plain English.

I'll describe breadboarder in a bit more detail in my next post.

An Adafruit proto Bonnet for the Raspberry Pi, Jetson Nano and Grove I2C

babelboard bonnet

Adafruit's protoBoards lets you make a bread-boarded design permanent, and Seeed Studio's Grove system lets you wire up a prototype really quickly.

In this half-day project I combined the two to create a simple, cheap, flexible prototyping system for the Raspberry Pi and Jetson Nano

The Grove system is based on standard 4-way connectors which can be used to connect digital, analogue and I2C-based components. I've focused on I2C since most of the robots I build use I2C to interact with their environment.

I mentioned the Jetson Nano - a hot topic at the moment, as NVIDIA have just announced a low-cost 2 GB version of the Nano which will be available at the end of the month. One of the clever features of the Nano is that it has a Pi-compatible header, so the bonnet will work on the Nano without modification.

Fritzing the design

I started by laying out an Adafruit bonnet design using Fritzing. The design is really simple. All it does is connect the pins of the Grove connector to the relevant pins on the Pi's GPIO header.

The only minor complication is that the Grove connector has 2mm spaced pins, but past experience has taught me that a little judicious bending allow you to fit one to a 0.1" spaced proto board.

A simple test

I tested the board using a Grove ADC board connected to a Grove potentiometer.

My ADC board is based on the ADC121. I've been a fan of the Grove hardware for a decade, and my board is an old one. It has a default I2C address of 0x55 unlike more recent versions which have a configurable address that defaults to 0x50.

I wrote a short Python script to read the voltage from the potentiometer and ran it. As expected, the voltage changed as I twiddled the knob. Success!

A quick demo

Here's a short video of the output from the zero as I twiddle the knob of the potentiometer.

I can now connect the zero to all kinds of useful I2c devices - servo controllers, motor controllers and a 9-axis motion tracking module.

Coming next

I'm working on an inexpensive LIDAR which reads distance data from eight VL53L1X Time of Flight Sensors using an MCP23008 port expander to selectively enable them. More details soon!