Seven steps to embedded designs made easier

with PSoC Creator

Anshu Kandhari and Naman Jain, Cypress Semiconductor
3/14/2012 05:50 PM EDT
Post a comment
NO RATINGS

Login to Rate

inShare
An embedded system is one with computing hardware that has software embedded in it as one
of its core components. We are surrounded by embedded systems that add luxury to our lives
like mobile handsets, washing machines, microwaves, ATM machines, and air conditioners, to
name just a few. Because of certain application requirements, engineers have to approach
embedded design in a different way than other types of designs.

The following offers a brief step-by-step approach to follow while designing an embedded
system:

1. Proposal: - An innovative idea or system that makes life easier and/or reduces the amount of
human effort required to complete a task.
2. Definition: - Next, the whole system needs to be designed, including what it will do under all
possible sets of input conditions. This definition is perhaps the most critical part, as any error
here will affect the working of whole system.
be,

I. I/O Considerations: - Defines that for a particular input, what the output of the system will
considering the system as a black box.
II. Mathematical Modeling: - Design the algorithm for the system to work as desired.

III. Functional Modeling: - Design the functions of the system which will accept input and
produce the desired output.

3. Technology Selection: - Based on the above points, designers then review available
technology and select which devices will fulfill all the requirements while balancing efficiency,
cost, and time-to-market.
4. Integration & PCB design: - List all the components, which you need to implement your
functions and design their placement on the PCB. Traces and all other paths must have the least
possible electromagnetic interference (EMI) and should be free from various errors. While
designing the PCB, special attention must be given to the ground as well as all the components
on the PCB that use ground.
5. Firmware Development & Debugging: - Since hardware needs instructions to execute the way
we want, we need to write the code for every component used by the hardware. This is exactly
what is done by the firmware i.e. the application code. Firmware should be of minimum
complexity. Moreover, as we write the code, we face many errors or bugs and for this we need a
proper debugging protocol.
6. Testing: Debugging tests the piece of code but in testing we test the whole system i.e.
hardware as well as the software that drives that hardware.
7. Documentation: Anyone who accesses your complete application should never ask you what
does this mean? or How does this thing work? and for this we need to document everything.
Problems with Current Design Processes:
While developing embedded applications, we need to understand different chips, their
capabilities, and their complex architectures before creating the system design flow. After this,
we need an application that provides functionality to our product and its components; and for
this, we have to write the code. But while writing the code, system requirements keep on
changing, and designers need tools that support for different debugging protocols. We may not
are not able to reuse our code and we want to encapsulate multiple features into a single system.
With all these issues, embedded system design demands consideration of factors such as Price,
Performance, Reduce time to market, Size, Power dissipation, Maintainability, Safety, Memory
etc of the complete system. Also, developers of embedded system wants to implement
programmable analog and digital peripheral on a single chip, thus, developing system on chips
(SOCs) is a highly tedious task for developers.
As the rising complexity in embedded systems mandates the need for programmability in almost
everything circumstance, designers need tools which can handle this painful job for us, and
provide a user-friendly environment in which to develop the application. Even though we have
some market based SOCs aligned tools, we are not completely aware of those tools
functionalities. Also, the tool must be able to utilize the features of the product to its maximum
potential. To illustrate this, we can take an example of chips that come with complex
architecture, combining almost all the analog and digital peripherals with programmability on a
single chip. We may not find it easy to read and understand the associated configuration register
and other low level aspects to use the device. This is where an intuitive system design tool that
hides lower level information and concentrates more on the system application comes in.

In short, we need a tool that reduces our time to market and takes care of all the developmental
considerations that too intuitively and efficiently. Also it should be cost-effective by allowing our
project to migrate from one chip to another depending upon the change in the requirement.
PSoC Creator:
Programmable system on chip (PSoC) manufacturers have recognized this need for developers to
have a complete system on a single chip which has both digital and analog functionality and that
too is completely programmable. In order to develop the embedded application that works on
these chips and provide solution to all the stated problems, Cypress Semiconductor offers PSoC
Creator. With its unique schematic-based format, PSoC Creator allows designers to develop
applications without having to manually mange the architecture or configuration registers. Now,
what exactly we have to do is to think of the design and just draw that design by dragging the
components either from the Cypress component library or from our own component library and
then drop them to design schematic. It is just like drawing the block diagram of a system,
independent of the device being used. This is possible because the revolutionary graphical design
editor enables a unique powerful hardware/software co-design environment. Note that this tool is
not only about combining software development environment with an intuitive graphical design
editor, but also enabling immediate testing of new ideas, rapid response to hardware changes,
creating libraries of sharable design elements, custom peripherals, error-free interaction with the
peripherals on-chip, and complete design realization using the built-in debugger.
In short the functioning and usage of this tool can be broken into 4 steps as shown by the
following figure:

Figure1. Steps to create project using PSoC Creator