Each intelligent shield needs a micro controller to implement the intelligent shield protocol.

The shield system uses the I2C bus, but adds dynamic address allocation. Therefore the will never be an address conflict between shields. The I2C bus is the low-level signalling used by the intelligent shields, above they use a the same higher level protocol. The I2C bus is used in multi-master mode, to enable a shield to send an interrupt on the bus. Multi-master means that there are several nodes on the bus that can initiate communication.

Apart from the I2C bus the intelligent shield system also contains an SPI bus, though the Slave Select (SS) signal is missing. To activate the SPI bus on a shield the equivalent of a Slave Select command is sent as a command over the I2C bus.


All signals but the Shield Enable is connected as a straight bus to every shield. The Shield Enable on the other hand is connected as both an input and an output signal. Each shields Shield Enable Output is connected to the next shields Shield Enable Input. This makes it possible to enable just one shield at a time.

The dynamic address resolution algorithm uses the Shield Enable to wake each shield in order, and give a unique address to each newly enabled shield. This algorithm has the advantage that the physical layout of the shields also become the virtual layout. When programming the fourth physical shield will also be the fourth logical shield.

Higher level software

Each shield implements a higher level protocol that uses I2C. The dynamic address resolution algorithm is part of this protocol. Other functions of the higher level protocols are:

Reflection. It should be possible to ask a shield what it can do.

Configuration. Some shields can be used in different ways. For example, a motor shield may be able to drive two DC motors or one stepper motor. For such a shield the user needs to configure what kind of motor has been connected. It is also possible to configure a static address, in case you need to use the shield in an existing I2C system that does not implement the high level protocol.

Configuration is also necessary to make it easy to bind the hardware to your software. For example giving a name to a motor. You could configuring that shield one has the motor named “left” and shield two has the motor named “right”. Then just use the names "left" and "right" in your software.

Debug. During development of a shield firmware it helps if you can get debug messages.

Firmware updates. Since each shield has a micro controller we are going to need to update its firmware. To make it easy we should be able to do that through the intelligent shield bus.

Of course the higher level protocol also has commands that actually do things, such as set the speed of a motor, the number of steps to move a stepper, and so forth. The commands are standardized – it does not matter which motor shield you use, they all use the same commands.

Backwards compatibility

As described above an intelligent shield can be configured with a static I2C address. After it has been given a static I2C address it can be used as any other I2C component. Thus an intelligent shield will work just fine as a shield for any system that uses I2C.

Any old shield or component that uses I2C can also be used together with intelligent shields. Just tell the new system that one, or more, I2C addresses are taken. The dynamic address resolution skips these addresses. Thus new and old can co-exist.

Furthermore, an old Arduino and shield can be made into a new intelligent shield. You just have to make a sketch that implements the commands necessary to use the old shield, and load it to your Arduino. Then the combination will make an excellent new intelligent shield. You do not have to throw away any old hardware just to use this new system.

Use existing CPU boards

This project will not build a CPU board. The idea is to provide a new, shield system for any existing Arduino, Raspberry Pi and similar CPU boards, not to create yet another Arduino clone with its own shield system. Instead we will build adapters for existing boards. The adapter for Arduino or similar is simple, just passive components. Unfortunately Linux does not support the multi-master I2C mode. Therefore the Raspberry Pi needs a more complex adapter.

It must of course be easy to connect the intelligent shield to a PC. Therefore we need an USB adapter. This adapter also makes it possible to connect Android phones and tablets, that support USB host mode.

For the Arduino we will make adapter boards both for using the Arduino as a CPU board, and for using it as an intelligent shield. One easy way to develop shields is to just provide firmware for making an Arduino + shield into an intelligent shield. This is something we will explore, since it is a good way to reuse old components.

Apart from the adapter board we will make a suitable enclosure that can be 3D printed. Every component of the intelligent shield system should become its own "lego brick", making it easy to stack together.


The first shield we will make is a prototype shield, for hacking.

Another important shield is a battery power shield, for LiPo batteries. Apart from powering a stack of shields, it is able to measure the voltage and give a good indication about how much power remains. Anything project built using this shield is able to warn when it is time to charge the battery.

Then we intend to build a motor shield, a servo shield, a led shield an IMU shield and a GPS shield. The motor shield should be able to drive DC motors as well as stepper motors. If we encounter problems there may be a separate stepper shield.

Bus extension

One of the good things with using I2C is that there are transceivers available that can extend the bus several meters. We will build a bus extension shield that uses such transceivers to extend the bus with a cable. Only the I2C part of the bus will be extended, SPI shields must always remain close to the CPU board. The extensions gives makers more choice for larger projects. For example, you could use the bus extension to put a motor shield next to the motor. Sometimes that will make for a cleaner design.


Quite a lot of software needs to be developed. One advantage of the project is that most of the software can be developed on existing Arduino hardware, rather than the untested shields.

The intelligent shield protocol is needed in two versions, one for shields and one for an Arduino CPU board. The protocol is not entirely symmetrical.

The firmware for each different type of shield.

The firmware for the Raspberry Pi adapter and for the USB adapter.

A library for using the intelligent shield bus on Linux.

Command line tools for configuring intelligent shields.

Possibly a GUI program and Android App for configuring intelligent shields.

Proof of concept

Once the shields and shield software is done we must prove that it is useful, and can actually be used to build real world projects. Therefore we intend to use the shields to control a hexacopter and an CNC router. The idea is not to write software to control the hexacopter or CNC router, but rather port existing software to use the new intelligent shields.