Embedded Design Services

An embedded design is a complex interactive design between software and hardware. An example would be a digital watch. Since most embedded systems perform one or just a few dedicated functions, design engineers can reduce the size and cost of the product while increasing its reliability and performance. Many of the circuits we design are of this type and we have become experts in this area.

In a practical Embedded Design, first, we design the main body and structure of the Firmware and then examine time critical tasks and ways of servicing these critical requirements. After drawing the big picture of software flow, we concentrate on the smaller modules and then finally devise a verification system to prove our design works.

Over the years, engineers at Arshon Technology have gained a wealth of experience and we have a complete library of ready to use embedded code which are fully verified.

Also, have developed a list of guidelines for Embedded Design that they follow in our design work. Below are some of them.

  • Keep the design simple and provide a clear definition of the software system integration.
  • Do not involve too many tasks in a feature.
  • Break down large and complex features into smaller features.
  • Draw message sequence charts for a feature carefully. Classify the legs of a scenario for a feature in such a way that similar message exchanges are performed through the common leg.
  • If a task is repeated in many places, make a function for it.
  • Provide a clear and complete definition of each message interface.
  • Check possible message loss by designing timer based message exchanges.
  • Always consider recovery and rollback cases at each stage of feature design. One way to do this is to keep a timer for each feature of the task that controls the mainline activity of the feature. Then insert the timeout leg in the message sequence charts of the feature.
  • Avoid overloading of message links by choosing design alternatives that include fewer message exchanges.
  • If using a state machine, be sure to have the definition of each state clear and verify the status of each state and all possible transitions between states.
  • Avoid using polling when critical timing is required.
  • Use a precise and predefined error messaging to increase the productivity and save in debugging time.
  • Use already proven modules, if possible, instead of writing the code again.
  • Always clear comments on the code.
  • Do not use "Go to" type of instructions.
  • Design the software architecture in parallel with the hardware design.
  • Be sure to have adequate understanding of the hardware capabilities.
  • Use global variables only when there is no other choice! Use local variables as often as possible.

To the layman, many of these guidelines will be meaningless. However, one can understand that the collective experience of the engineers at Arshon Technology will undoubtedly help to accelerate product development.

You may also check our Portfolio.