News Archive (1999-2012) | 2013-current at LinuxGizmos | Current Tech News Portal |    About   

An electronic ‘LEGO’ for embedded systems

Jul 8, 2008 — by LinuxDevices Staff — from the LinuxDevices Archive — 14 views

Foreword — This article describes the development of an interesting uClinux-based embedded computing platform that uses the CompactFlash form-factor. Envisioned as a way to exploit CompactFlash cards as COTS (commercial off-the-shelf) peripherals, C Data Solutions products target rapid prototyping of handhelds, industrial, and networking gear.

The original Compact Flash Computer shipped in 2004. Based on a 68K ColdFire microcontroller running uClinux, it used a programmable logic device to drive a CFIO bus that developers could populate with CompactFlash cards of their choice, to quickly cobble together miniscule Linux systems. That design evolved to the CompactComputer (CoCo) version, which along with a much faster Blackfin DSP/FPGA processor, adds a CFIO client interface. Enjoy . . . !

An electronic “LEGO” for embedded systems
by Paul Zawalnyski

The Compact Flash Computer was the outcome of a customer requirement. Our client wanted a real-time data acquisition system for a wind tunnel model. The system needed to transmit data wirelessly or via a single wire. The challenge was that the customer only wanted two of the devices, precluding a custom design.

Clearly the project required COTS (commercial, off-the-shelf) hardware. We looked at lots of nice single board computers (SBCs), but they did not have the right mix of input and output. The PC/104 format seemed to fit the requirements, but it was too big to fit inside the wind tunnel model.

That was when we had our “Eureka!” moment. We realized that there are COTS boards much smaller than the PC/104 that are manufactured by many companies and ship in millions. They go under the names PC-Card, CardBus, and CompactFlash. Why wasn't anyone designing embedded systems using these tried and true formats? The big problem, we realized, was that in most cases, only two of them could be used at a time in a laptop, which was too big and too expensive for use as an embedded solution.

The challenge was to develop a processor that could talk to multiple cards. This was pretty straightforward, as long as all the cards were the same format. The problem was that PC-Card and CardBus cards are hard to tell apart. If we built a system that could only use PC-Card or CardBus, there would be numerous customers who would populate the system with the wrong type of card, leading to a support nightmare.

So we chose CompactFlash, which is today used for a wide variety of applications, including Ethernet, wireless, Bluetooth, ZigBee, GPS, GPRS/GSM, ADC/DAC, and storage. We came to realize that miniature embedded systems could be developed using commonly available, low-cost CompactFlash cards. At 1.6 x 1.6 x 0.2 inches (4 x 4 x 0.5 cm), they were 1/30th the size of PC/104 cards, and there would be minimal hardware development or NRE (non-recoverable expense) costs involved. People could build rapid product prototypes in a matter of days or even hours.

C-Data Solutions CompactFlash Computer
(Click to enlarge)

If this is such a good idea, why had no one else come up with it?

I recalled a manager who once told me there were two reasons why certain products don't exist: it's either a stupid idea or nobody has thought of it. I decided to go with the second one.

The goal was to have a system you could plug any CompactFlash card into, and it would run without modifications. Users would be able to swap out an Ethernet card for a WiFi card without making software modifications.

Rapid prototyping with wired and wireless cards
(Click either photo to enlarge)

To meet this goal and achieve wide-scale adoption of a CompactFlash-based computer, we realized that the software had to be standards based and run on a standard embedded operating system. We considered Linux and WinCE. After realizing that the drivers for the CompactFlash cards might have to be modified to support the architecture, we decided that Linux was the obvious choice. With an estimated 18 million Linux developers in the world, there would be a ready-made market. In the end we went with uCLinux, which continues in the next-generation product as well.

The first generation: Compact Flash Computer

After a lot of hard work, compromises, and layout changes, the first Compact Flash Computer was created. It was based on a Freescale MCF5272 processor running at 40MHz, with 8MB FLASH and 16MB SDRAM. The system acted as a CompactFlash host that controlled other CompactFlash cards, and was originally supplied with a 10-slot motherboard measuring 52 x 42 mm. Later, this evolved into a low-cost, four-slot carrier board.

The original CompactFlash Computer, and the four-slot carrier board
(Click either to enlarge)

The system generated a lot of interest. Companies used it for rapid prototyping and proof of concept engineering. Individuals developed small systems. The projects ranged from wireless health monitoring to GPS logging and data storage.

Yet, many developers wanted it to do more — more than we had originally thought they would need. For example, developers wanted to plug it into a CompactFlash card slot in existing equipment, cameras, and PDAs, and develop applications such as:

  • Secure applications for PDAs
  • Accelerators for existing equipment, allowing new functionality with the original processing budget
  • Emulating storage cards in existing equipment such as cameras and data-loggers, providing access to the files via wireless or serial communications
  • Additional digital I/O for systems with a CF slot. For example, tiny add-on cards that could contain ADC or DAC clips with a custom connector

The problem with all these scenarios was that the Compact Flash Computer was designed as CompactFlash host, and could not itself be plugged into a CompactFlash socket. So we set to work on the next generation.

The second generation: the CompactComputer

One of the compromises we had made in the original design was to add a small PLD (programmable logic device) to generate the CF bus signals. This was done to ensure that the board layout could be achieved in a reasonable number of layer and line widths. The solution for the next-generation system was to replace the PAL (Programmable Array Logic) PLD with an FPGA (field-programmable gate array). This would allow the CompactFlash bus to act as either a host or a device, and offered the benefit of enabling bus reconfiguration. Many system functions could be offloaded from the carrier board to the FPGA, and multiprocessor systems could be developed with custom communication systems, shared memory, or message passing. For the first time we would really have a true electronic LEGO.

FPGA selection now became the critical design decision. Because we needed to add a 37 x 25 mm top connector, board space had shrunk, so that was also an issue. At first, we considered using a soft-core processor in the FPGA, which would give us a claimed 100MHz performance, but which we found was reduced to 50MHz once the FPGA was loaded with functions. We realized that going from 40MHz to 50MHz was not going to be a “wow” factor for anybody, especially when similar systems were running at 400MHz.

So there was no other choice: the new system had to have a processor plus FPGA. The Analog Devices Blackfin DSP (digital signal processor), which includes an embedded FPGA, quickly emerged as the best option. The Blackfin offered 500MHz to 600MHz performance, with plans for ramping up to 750MHz, providing long-range upgradability. It also offered a modest 12 x 12 mm size and 0.8mm ball spacing, which would make the layout and manufacture easier.

CoCo board
(Click to enlarge)

Still, space was tight, and layout was a major challenge. All the computers in the company were running PCB routing programs 24 hours a day, seven days a week for a very long time. We iterated the design through different SDRAM, and Flash devices until at last, a board layout was found that could be manufactured at reasonable costs.

In December, we finally gave our PCB routing programs a rest and shipped the CompactComputer. The device offers a complete miniature embedded system using COTS hardware at a fraction of the size of existing industrial solutions.

The next step is to enable developers to take advantage of this technology and reap the benefits, by releasing dev kits that specifically address different market sectors:

  • Handheld devices
  • Data acquisition
  • Commercial equipment (PDAs, cameras, etc.)

Additionally, we hope to provide OEM services to take the basic technology through to a finished product. Small volume users would buy the CoCo card, while larger-volume customers may manufacture CoCo themselves, or translate it into their product design via an OEM agreement.

We also plan to scale the technology into different form factors and application areas. We don't want our developers to be constrained by the attitude of “nobody else does that.” By taking advantage of true plug and play embedded systems, we can change the way that prototypes are developed.

About the author — Paul Zawalnyski obtained a 2.1 Degree in Electronics at Dundee College of Technology, Dundee, Scotland, and a Diploma in Digital Techniques from Heriot-Watt University, Edinburgh, Scotland. Since graduating, he has spent 25 years developing hardware and software in the military, medical, and networking industries. C Data Solutions was formed late 2004 specifically to develop the Compact Computer and modular embedded systems.

This article was originally published on and has been donated to the open source community by QuinStreet Inc. Please visit for up-to-date news and articles about Linux and open source.

Comments are closed.