Besides the advantage of higher performance in performing calculations and faster data transfers, what are the advantages of working with an MCU that has a larger bus width?
MCUs with higher data bus widths enjoy higher performance in terms of faster operations, often more powerful development tools, more features, and better power efficiency. In general, lower bus widths limit performance in exchange for a slight cost benefit to a project’s budget. In this article, consider all discussion below to include 16-bits somewhere in between 8-bits and 32-bits. However, 16-bits will lean towards 32-bits in what it can offer in performance benefits, how it’s programmed, debugged, in cost, in labor, and…in general.
The number of cycles increases as the bus width decreases: Lower bit widths require more cycles to complete larger computations. It takes more cycles for an 8-bit MCU to complete a large computation than MCUs with a 16-bit data bus width. Using a 32-bit MCU can reduce computational cycles down further. Besides speed in completing calculations and in data throughput, a 32-bit MCU can handle operations in one cycle that an 8-bit MCU would need many cycles to complete. If there’s an interrupt or failure in the middle of a transfer, the 8-bit MCU has a greater chance of not completing the task, with several cycles required, versus a 32-bit MCU that completes the same task in one cycle. If computational speed and throughput are important, 32-bits is better for throughput. Examples include computation-intensive applications like image processing.
Cost: 8-bit MCUs are still prevalent and in some applications the cheapest computational option out there regarding chip cost. However, 32-bit MCU chips can be just as inexpensive as some 8-bit MCU chips. When shaving off hundredths of a cent is important, such as in high volume products, the decision will be made based on minimum project requirements that are satisfied by the least expensive chip, regardless of bit width. It may not be a consideration to future-proof products to add more features. Regarding skill-sets, once engineers master the learning curve for 32-bit devices, the value extends a to wider reach in applications. The scope of an 8-bit MCU is significantly limited with respect to 32-bit MCUs. Labor costs may also be less in working with a 32-bit MCU, as more options, features, tools, and a larger existing body of code develops around the 32-bit ecosystem. Cutting edge technology does not evolve around 8-bits any longer.
Code size: The greater the width, the denser the code will be. A 30% reduction in code size is a rough estimate of the benefit that code written for 32-bits offers over 8-bit code. Programming with 32-bits is much more challenging in assembly code than 8-bits, of course, but modern development tools enable engineers to work in C/C++, a language often portable across architectures, and with similar tool chains and IDEs across architectures. However, 8-bit MCUs can be coded more efficiently with assembly code for engineers who take time to think through the efficiency of operations, which is an effort that can be more of an art than a science.
More features: There are simply more features to take advantage of with the higher data bus width architectures. The scaling of features can increase significantly with 32-bit devices, with much greater rate of integration of peripherals as bit-width increases. Real-time performance is easier to reach in 32-bit devices with a DMA to skip the CPU entirely.
Nevertheless, there is a larger selection of 8-bit MCUs available than 32-bit MCUs. Part of the reason for this is that 8-bit architectures have been around for a much longer time than 16- and 32-bit architectures.
Many 8-bit MCUs are chosen primarily based on per-MCU cost, re-use of legacy code, and personal familiarity with 8-bit architectures. 8-bit MCUs can get the job done with minimal requirements, but the skill set required for developing products with 8-bit MCUs is different, most noticeably when working at the lowest level of programming: assembly code. Assembly code can be written much more efficiently than what a compiler can produce from higher-level programming in C/C++, for example. But the devil is in the details; if time is of the essence, working with a 32-bit architecture on modern tools can require less effort and finesse than when working with an 8-bit MCU.
Some people simply prefer the easy ability to “bit bang” with an 8-bit MCU, which is more transparent in that it’s less complex to follow operations, especially for lower-level debugging. Those who prefer 8-bit MCUs may appreciate the fact that they have more control over the 8-bit MCU, which is more transparent in that it’s easier to follow what’s happening at the lowest levels. But working with 8-bit MCUs can also require a greater knowledge of MCU operations and memory management than one has time for. It’s a trade-off in terms of the complexity of actions that you can create in 32-bits against the more abstracted layers of programming with 32-bits which leaves you farther away from the silicon.
The decision on whether to work in 8-bit or 16- and 32-bits depends on what the application requires, the ultimate cost of the MCU and development labor, the need to future-proof the application’s capabilities and features, and how time-to-market considerations. Many developers are die-hard fans of 8-bit MCUs and can do amazing things with them. Very high-volume products will gravitate towards the least-cost device option regardless of (seemingly) one-time labor costs. In the end, the choice depends on trade-offs. As a decision for personal development, it’s wise to be familiar with both. The visibility of the core operations of an MCU at the 8-bit level offers an educational experience that is often hidden by layers of abstraction with 32-bits. However, the places you will go with 32-bit development skills outpace what 8-bits can offer when you consider the increasing complexity of modern technology.