This page has been renamed to Electronics Development Board.
Please update your bookmarks, and wiki pages which link here
I love prototyping with Arduinos, but I don't like the rats nest of confusing and badly fitting wires when using a breadboard. I also hate soldering things onto vero board, before my design has taken shape. De-soldering sucks! I want the solidity of real circuit boards, and the flexibility of breadboards. My soldering iron should only be fired up when my design is pretty well developed. Breadboards are only useful for small projects.
Also, I don't see why my electronic prototyping process should change, when I switch to a different microprocessor. There's lots of choice : Arduino, Raspberry Pi, PIC, numerous WiFi enabled SOCs. I want to prototype with all of them!
Most of my projects need buttons, LEDs, potentiometers, maybe a rotary encoder or two, a screen, IR transmitter/reciever. I want to plug these standard components together in seconds, leaving just the non-standard stuff for the breadboard.
- Module Connector
- Serial Connector
- PIC Main Board
- Arduino Main Boards
- Arduino Main Board Connectors
- 8 LED Array
- 8 Momentary Buttons
- RGB LED
- Driver Board for LED Strips
- Rotary Encoder
- Shift Register
- Line Shuffler
- Level Converter
- RF Transceiver
- Real Time Clock
- Motor Control
- Servo Motor
- Arduino Bootloader Installer
- OLED Display
- Seven Segment Displays
- Midi Port
- Mini Breadboard
Create modules, which do one thing and do it well (from Unix Philosophy).
Have a "main board" at the centre, housing the CPU. The modules shouldn't care if the main board houses an Arduino, PIC, a Raspberry Pi etc.
Define a standard connector, allowing modules to work together. Yes, I am aware I'm falling into the "XKCD Standards Trap".
Allow modules to be chained together in flexible ways.
It must be expandable. Shift registers / multiplexers should work seamlessly with existing modules. For example, it should be easy to hook up 24 buttons, by using three of the 8-way button modules. Similarly, for 24 individual LEDs. Try that on a breadboard without going bat-shit crazy!
To get everything to work together, we need a standard connector, and a way for modules to be chained together.
Here's the pinout for the connector :
The pinout :
- a gap
- Data lines 0..7
Each module will have a main connector on the left edge, and a female on the right edge. Modules can be chained together in a line. FYI, I've seen similar systems, which stack boards one on top of another. IMHO, that's crazy. With just two boards (LEDs and buttons), which should be on top? The LEDs (so you can't press the buttons), or the buttons (so you can't see the LEDs)?!?
Why 8 data lines?
Given that both the Arduino and PIC chips have a natural grouping of 6 data lines, why choose 8?
I want to use the same expansion boards connected to shift registers, and multiplexers as well as directly to the main board. Shift registers and multiplexers work in groups of 8, and if we only had 6 data lines, this wouldn't work well.
Why so many power lines?
Most boards will only use Vcc, so they can omit 3V3,and Vin if they wish. Place boards that require multiple power lines nearest the main board, and boards with only Vcc at the end of the chains.
A connector designed for modules using SPI, I2C or UART.
The layout is the same as a regular connector, but the pins have predetermined purposes. This makes modules using I2C / SPI / UART compatible with any main boards; the modules do not have to make hard-wired assumptions which only work with a single microprocessor.
- a gap
- 7 UART : Rx (Arduino D0)
- 6 UART : Tx (Arduino D1)
- 5 I2C : SCL (Arduino A5)
- 4 I2C : SDA (Arduino A4)
- 3 free
- 2 SPI : MOSI (Arduino D11)
- 1 SPI : MISO (Arduino D12)
- 0 SPI : SCK (Arduino D13)
Note. The pins have been chosen so that when using an Arduino main board, an I2C module can be plugged into the bottom edge, and an SPI or UART module can be plugged into the left edge.
What should be in the "free" spot? Doesn't make sense to use SPI's slave select (SS) (Arduino D10).
PIC Main Board
A ZIF socket to house the PIC chip. Programming header pins. Should be compatible with various PIC chips. The smallest only have 6 GPIO pins, and therefore need only one module connector, with two of the data lines not being used. Larger PIC chips with 12 GPIO pins will use module connectors on the left and right of the board; both with two data lines not used. It's unlikely that I will support PIC chip with more than 12 GPIO pins, but a larger main board, with more than 2 module connectors is obviously possible.
Arduino Main Boards
Arduino Nano Main Board
Two rows of female headers to house an Arduino Nano.
Arduino Pro-Mini Main Board
Two rows of female header pins to house the Pro-Mini.
Non-standard Analog Pins
The analog pins A4..A7 do not have standard pin placements.
Some have A4 and A5 near to the A3 pin, but not aligned nicely. Other boards have them at the opposite end to the ISP header (only sometimes nicely aligned). Sometimes A6 and A7 are also present.
Did they learn nothing from the stupidity of the original Arduino's crappy, non-aligned headers? Grr.
I'd like to ignore A4, and A5, but they are also used for I2C, which I would really hate to leave off. So, I'll add male header pins, and let these be connected to the Pro-Mini using jumper wires. The Pro-Mini can be fitted with male header pins too - possibly right angled versions, to make it low profile.
A ZIF socket for an ATMEL chip, plus the resonator and capacitors.
ICSP header pins, to upload sketches.
Options for power supply :
- None - just use the power from the ICSP header
- 9-12V input jack, with 5V and 3.3V regulators.
- Either a jumper, or protection circuitry when two power sources are attached.
- Somewhere in between.
Arduino Main Board Connectors
From top to bottom :
Vin, 3V3, VCC, GND, gap, D9..D2
It starts at D2, because D0 and D1 are specialist UART pins, which are used by the serial communication, including uploading sketches, and debugging using the serial monitor. Therefore, these are rarely used as general purpose I/O.
From right to left :
Vin, 3V3, VCC, GND, gap, A7..A0
A7 and A6 cannot be used for digital input or output.
A5 and A4 are shared with I2C SCL and SDA.
From bottom to top :
Vin, 3V3, VCC, GND, gap then...
- D0 (Used by UART Rx)
- D1 (Used by UART Tx)
- D10 (AKA SPI SS)
- D11 (Also used by SPI MOSI)
- D12 (Also used by SPI MISO)
- D13 (Also used by SPI SCK)
A serial connector (see below).
All of these connections are duplicated elsewhere, but having them in a standard configuration allows serial modules to be compatible with non-Arduino based main boards.
8 LED Array
Powers 8 LEDs directly from the data lines. Each line can be enabled/disabled using DIP switches.
There can be two varieties - common anode and common cathode. The circuit board is the same, but the LEDs are put in opposite way round.
Another detail will make it much more useful - do not connect the common anode/cathode directly to GND/Vcc. Instead, have a jumper cap, which in most cases will stay in place all the time. However, you can remove the cap, and connect it via a jumper lead to another board to enable/disable the whole bank of LEDs.
This jumper will also be used by the 7 segment display driver (see further down), so that it can use these 8 LED arrays as one of its four banks of outputs.
8 Momentary Buttons
8 switches, with pull up resistors. Each line can be enabled/disabled using DIP switches.
Power a single RGB LED. This will typically be from 3 PWM pins, but could use software to pulse the pins too. There's header pins for each of the 8 data lines for connecting three jumper wires (red,green, blue). The LED has a common cathode (but another board could use a common anode).
Driver Board for LED Strips
Similar to the RGB LED board above, but instead of having an LED, there is a connection for LED strips. There's also three MOSFETs to power the LEDs. The power is taken from the Vin connection.
Could make two versions, one for command anode, and another from common cathode.
A board with 1 (or more?) potentiometers.
8 header pins, and a jumper wire to connect the pot to a line of your choice.
A board with a single rotary encoder dial, plus a switch when pressed.
8 header pins, and three jumper wires to connect the rotary encode + the switch. Complete with three pull-up resistors.
There are two varieties, a master and a slave.
The master board allows the clock, data and latch pins to be selected from any of the eight data lines from its parent. Unlike most other boards, its child data lines are NOT a copy of the parent data lines. They are the outputs from the shift register.
The master also has a connection pointing upwards, for slave boards.
The slave boards take their inputs from the bottom edge, and the outputs of the shift register are on the right edge. In addition, its top edge has another connection, allowing more slave board to be chained together.
The net result, is a limitless number of output lines, all of which can be used to control any sub-boards, such as the 8 way LED board.
Designed in a similar was as the shift register, allowing for large number of input or output lines.
The 4051 chip uses 3 address pins, one I/O pin and a chip select, giving expansion to 8 I/O pins. That's not much of a saving! However, to get another 8 I/O takes just one more pin (because the address pins can be shared by both multiplexers).
If a sub-board has hard-coded which data lines it uses, but you want to do things your own way, Line Shuffler can help. Simply 8 header pins on the left and right of the board allowing you to add jumper leads to change the number downstream. If a jumper lead is missing, that line will be disabled downstream, which may be useful too.
I don't intend to hard-code data line choices on my boards, so it's unlikely I'll need a line shuffler.
If the main board uses 5V logic, and a sub-board needs 3.3V, then place a level converter in the middle.
Use 8 MOSFETs to convert each of the data lines as described here. In addition, Vcc is mapped to 3.3V on the child side. The other power lines are passed through unchanged as usual.
Maybe include an option to use the 3.3V supply from the main board, or use a voltage regulator on the Level Converter board. Use a jumper to select which option, and another jumper to enable/disable the voltage regulator.
It's conceivable that we'd need a 3.3V to 5V version too - if we use a 3.3V main board, and want to control 5V peripherals.
Increase the number of PWM channels by using external PWM chips.
These should be chainable, with a master module and slave modules, in a similar manor to the Shift Registers, allowing for a large number of outputs.
The PWM chips I own can be controlled via one of Arduino's PWM pins, or using their own resonator, and control circuitry. Try both?
Real Time Clock
I have spare RTC chip lying around!
Arduino Bootloader Installer
The Arduino on the main board acts as the gateway to install the bootloader onto a bare ATMEL chip.
Maybe use the same board as the DIY-Duino main board. But all sides are being used (left/right : modules, bottom : analog, top : serial).
So create a simple converter board, which allows the serial connector of the Arduino Nano main board to connect to the serial connector of the DIY-Duino main board. Male pins on both sides, and no components - just wiring. (Maybe protection circuit in case both boards are powered).
Tiny OLED displays can be useful, and they come in two varieties: SPI and I2C. For prototyping purposes, it will be nice to be able to plug in both varieties in.
So two rows of female headers, and a bit of wiring.
For SPI, we also need a "Slave Enable", which can be a header pin, with GND next to it. Therefore it can be permanently enabled using a jumper cap. A jumper wire can be used from elsewhere if you want to control more than one SPI device.
Seven Segment Displays
A TM1637 chip can drive 4 seven segment displays (while also handling switches too). However, we may also want to use this device to drive something other than a 7 segment display - a level meter for instance, showing the battery's charge, or a volume display for audio projects etc.
Therefore, I'd like the module containing the TM1637 to have no LEDs, but instead rely on daughter boards for the actual display. We can use the bog standard 8-way LED module as one of its daughter boards.
So we need a 7 segment driver module, as well as 7 segment display modules. The driver can chain up to four of these in a row, with jumper leads on each to select the correct bank. A seven segment displays can be used directly from the main board without a driver, but of course, that would use 8 valuable pins!
A simple 'wiring-only' board, with a 5 way din socket. A jumper to select input or output. Hard-wired to use lines 0 and 1, which are Tx and Rx from the Arduino, but could use software based implementation of UART.
The simplest module possible. Just some female header sockets for the data and power, and a blank space to stick a small breadboard.
A really simple board which allows up to 3 modules to be attached. Modules such as the Shift Register module, and the multiplex module are "dead ends" - the data lines from the main board stop, and are replaced with new data lines. This isn't usually a problem, because you can place these dead end modules at the end of a row. However, sometimes, you may need two dead end modules.
The junction module passes the data lines from left to right as normal, but also connects them upwards and downwards too.
Note. I could have a lot of these professionally made, and use them as the base layer for other modules. Have options for header pins, and prototyping board grid of holes in the middle. Maybe a DIP style too.
When the I2C I/O expander chip arrives (PCF8574P), create a "debug" module. Have a screen and some buttons/switches. Switches can determine which debug statements get printed out. A "break" switch can pause processing (by entering a loop after printing) A button can single step to the next print.
By using I2C for the screen and the buttons means that only 2 pins are used from the arduino (A4,A5), so less likely to impact on the circuit's design. Useful for debugging when serial monitor is not available.