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.
A development kit is a platform that supports development of applications on the CPU. These kits offers users an easy and flexible environment, and come with on-board programmer, portable headers like Arduino compatible expanders, the ability to measure the system current, multiple power supply options, and accessibility to all the blocks / GPIOs of the CPU. If your team has chosen a specific 32-bit CPU and you want to start developing your application immediately without having to wait for your own hardware to be developed, development kits are the best choices. Let us consider an example of a thermal printer system design. You would need a hardware platform that allows you to implement all the features of thermal printer in a single board.
Figure 3: Thermal printer kit system architecture block (Source: Cypress Semiconductor)
Figure 4: Thermal print development kit (Source: Cypress Semiconductor)
As an alternate, if you are in the process of selecting the right CPU for your application need, a quick prototype may help to decide whether the target processor is serving your needs. In such scenarios, a prototype kit will be very helpful. These kits offer accessibility to all device IOs but no other major built-in features. The aim here is to use these kits as a disposable testing platform in bench testing or in an end-product environment. For example, you may just plug-in this board into your existing end-system to replace the CPU and quick make a prototype to test performance under real operating conditions.
Figure 5: Prototyping kit example (CY8CKIT-059)
It is no longer true that it takes more time to learn a 32-bit MCU as it does an 8-bit MCU due to higher complexity. Most vendors provide sets of tools that give customers easy access to ready-made microcontrollers that have already been debugged. In reality, developers don’t realize that they aren’t learning about microcontrollers, per se but are learning to use a set of tools to configure the MCU for their applications. These easy-to-use tools relieve them of the burden of learning about all of the details that go into making the microcontrollers work.
To further simplify design, MCU vendors also provide a rich set of projects so developers can quickly learn about devices. These projects also speed application design. Projects vary in complexity ranging from simple code to learning to configuring IP in a tool or universally accepted tool to complete ready-made reference designs complex firmware. Thus, the best way to learn any microcontroller is to buy a ready-made board and start developing an application as this does not requiring developers to spend lot of time learning the hardware details of the microcontroller. To give an example, to learn a Programmable System on Chip (PSoC) device, Cypress provides a rich set of simple code examples to learn components for various IP blocks and application notes to help design complex applications.
click for larger image
Figure 6: Code example projects with sample code in PSoC Creator (Source: Cypress Semiconductor)
Anbarasu Samiappan is a Senior Applications Manager at Cypress Semiconductor. He is managing PSoC Embedded Systems Group including Customer Technical Support and System validation functions. He is a PMI certified Project Management Professional, Gold medalist Electronics Engineering Graduate from Anna University and earned General Management credential from IIM, Bangalore. He has 19+ years industry experience. Anba can be reached at .
Jaya Kathuria works as an Applications Manager at Cypress Semiconductor Corporation where she is managing the Embedded Applications Group and Solutions Development using the PSoC platform. She has 11+ years of experience in Semiconductor Industry. She earned executive management credential from IIM, Bangalore and holds BS in Electronics Engineering from the Kurukshetra University. Jaya can be reached at .