Upgrading 8- and 16-bit MCU designs: Development ecosystem
In the first article of this two-part series, we discussed how the integrated architecture of 32-bit MCUs provide OEMs with a way to upgrade 8- and 16-bit systems in terms of performance, power, and advanced analog and digital peripherals. In this article, we’ll cover how modern software tools, hardware development ecosystems, and ready-made firmware stacks with code examples ease system design and development of 32-bit systems.
Designing complex systems
When you migrate from 8- or 16-bit to 32-bit, it might seem that your development ecosystem would become more complicated given the need to deal with a more complex CPU core, rich register sets, and additional peripherals. To minimize this complexity, MCU manufacturers abstract many elements of design through software tools and libraries accessed through an integrated development environment (IDE). The industry follows the trend of providing a single development environment that supports 8-bit and 32-bit architecture to enable the easy and seamless porting of designs. For example, prominent IDEs like IAR’s Embedded Work Bench, Cypress’ PSoC creator, Keil’s uVision, MPLAB, and others all support 8-bit and 32-bit processors in the same development environment.
Advanced IDEs not only act as an integrated compiler, programmer, and debugger, they also enable concurrent hardware and firmware development using the same tool. This allows developers to configure programmable hardware resources in conjunction with software design using a graphical design editor. Such a hardware/software co-design environment can greatly simply design. For example, device hardware features are abstracted as libraries that are pre-verified, production-ready components for both analog and digital blocks. The IDE automatically places these components into the selected target MCU, then routes all on-chip signals and directs I/O for optimal pin placement. Each library component is parameterized so that the implementation is automatically configured to match the requirements of the application and avoid wasting resources.
For example, the PSoC Creator IDE consists of two basic building blocks: the program that allows the user to select, configure, and connect existing circuits on the chip; and the components that are the equivalent of peripherals on MCUs. With integrated programmable logic, developers can also create their own application specific peripherals in hardware. PSoC Creator allows much freedom in the assignment of peripherals to I/O pins. The register set of the underlying hardware is abstracted as a consistently-named set of APIs so that the firmware developer need not to worry about particular silicon details between chips. The IDE also enables seamless porting between 8-bit and 32-bit designs and allows users to export the hardware design from this IDE to any standard 3rd party IDE like IAD, Keil, and Eclipse for firmware development.
Figure 1 shows the layout of the PSoC Creator IDE to illustrate designing with the advanced tools available to developers. The rich set of hardware abstracted libraries (marked as “1”) are readily available as drag and drop components for placement in the schematic editor. Components can be interconnected just like a Lego-based design in the schematic editor area (marked as “2”). Each component has a GUI-based configuration console (marked as “3”) to tune the components as per application requirements. Each component is supported with a detailed description in the form of in-built component datasheet (marked as “4”). After the entire system is build and generated, user firmware source code is available on the left side pane (marked as “5”). These are provided with a high level application programming interface (API) allowing user to write application code easily and effectively. Figure 2, shows the complete system example of a fitness tracker application.
click for larger image
Figure 1: PSoC Creator features - advanced MCU tool example (Source: Cypress Semiconductor)
click for larger image
Figure 2: Fitness tracker application example using PSoC Creator. (Source: Cypress Semiconductor)
Embedded system design engineers looking to upgrade from 8-bit legacy design to a 32-bit ARM CPU can benefit from the powerful CPU and software ecosystem. It is also very important to understand the hardware development ecosystem to judge whether the 32-bit migration really helps to meet their product objectives. End-customer expectations continue to increase and so designers are seeking improvement in every aspect of their work to reduce development and evaluation cycle time, re-use hardware and software blocks, and improve the quality of the end product at a low cost.
To help with this, hardware kits from CPU vendors can be used to assess a particular 32-bit CPU. However, the needs of each applications differ according to where they are in the respective stage of their product development life cycle. There are various types of hardware kits available in the market for a given CPU, including development kit, evaluation kit, prototyping kit, reference design kit, and modules. This is particularly true for 32-bit processors compared to 8-bit processors as the industry continues to shift its focus towards the 32-bit market. In this myriad of options, it is important to know how and when to choose a right kit so that it can help to get your design quickly to market.