Freescale is a world leader company in embedded control, having pioneered the microcontroller technology and introduced the first flash memory based MCU.

What is the Controller Continuum?

The Controller Continuum roadmap provides a stepwise compatibility allowing an easy migration either in the up or down direction among the Flexis family MCUs. Starting from the RS08 entry-level device, up to the top performance ColdFire V4 microcontroller, the Controller Continuum helps developers to easily move from one device to the next compatible one, from the entry level to the high end of the continuum. That is possible because all the Flexis family members share common packaging, peripherals, development tools, reference designs, application notes, and pin-outs: the compatibility between 8 and 32 bit MCUs is the revolutionary idea which is behind Freescale's Flexis series of MCUs.

The Controller Continuum is correctly defined as a path. Customers can choose the proper MCU basing on the level of performance they want to achieve and on the price they can afford: if however in the future they want to move to a higher level of performance, they just have to follow the continuum, which helps to save money and time providing a grade of compatibility never seen before.

The following picture represents the Freescale controller continuum diagram. The starting point is occupied by the RS08 core; from there, moving in the direction of growing performance and integration, can be found the S08 and the ColdFire V1-4. The connection point between 8- and 32-bit microcontrollers corresponds to the transition between the S08 and the ColdFire V1 MCUs: both of them share common peripherals and common development tools, so that the migration can be executed easily with little effort.

The controller continuum helps to resolve the potential difficulties which a hardware designer and a software developer might face when a migration has to be done. A list of possible critical points is as follows:

• Software tools can be different: as a result, source code might be modified in order to be compliant to the selected compiler and to its libraries. Moreover, even hardware development tools can be different. This fact implies additional costs and waste of time
• The hardware peripherals can be different: that means that low-level software (the drivers) shall be rewritten or at least modified in order to reflect the new registers and memory architecture. Drivers are very critical, so more time for coding, debugging and testing will be required
• The pin-out of the devices most of times is different: as a result, the board layout has to be rearranged, and possible conflicts with the rest of the board might rise.
• Power supply can be different: that means that additional hardware might be requested to meet the new supply voltage requirements.

The Flexis series of microcontrollers help to prevent these kinds of issues because they have:

• a single development tool to ease migration between 8-bit (S08) and 32-bit (CFV1): the same CodeWarrior versions support both cores
• a common peripheral set to help migration from 8-bit to 32-bit devices
• pin compatibility to help hardware reuse when moving between 8-bit and 32-bit

Freescale has also defined a roadmap for the controller continuum, as depicted in the following picture. Devices with the same color have pin/peripheral compatibility. The third step of the controller continuum roadmap is represented by the new series of Flexis MCUs, the Flexis AC family, especially targeted for industrial application.

The following picture shows the hardware architecture shared among S08 and Coldfire V1 MCUs: since both cores are sharing the same peripherals, the migration of an application from one MCU to the next one is not a hard task, and it can be performed through the development tool CodeWarrior 6.0.

There are, however, some common mistakes that shall be avoided in order to obtain an easy migration of the application, thus reducing the porting issues. Some useful tips to achieve that task are the following:

• Do not use (or remove) the in-line assembly code. S08 8-bit MCU and ColdFire V1 32-bit MCU have different instruction sets, so in-line assembly instructions will produce a compiler error when the migration is requested. In-line assembly instructions shall be replaced with C code
• Assign interrupt vectors using interrupt declarations in CodeWarrior header files. S08 and Coldfire V1 have different interrupt vector tables, and they reside in different memory locations: if the interrupt vectors are assigned using the CodeWarrior declarations, all of the migration work is done by the compiler and the source code is more readable
• Reference memory using Register_Bitname peripheral declarations in CodeWarrior header files. S08 and ColdFire V1 have different memory maps, so absolute memory declarations shall be avoided: let CodeWarrior linker do that job for you
• Avoid software delays based on instruction cycles. S08 and ColdFire V1 execute the same code with different timings: S08 instructions are executed at bus speed, whereas Coldfire V1 instructions are executed at the CPU frequency. Software delays based on NOP or similar instructions shall be avoided or removed and replaced with software delays based on the hardware timing peripherals such as TPM and RTC

The Flexis AC family of microcontroller

This new MCU family, that includes the AC128 and AC256 models, is the third step of controller continuum roadmap. The S08AC128 (8-bit microcontroller based on the S08 core) and MCF51AC256 (32-bit embedded controller based on ColdFire) are designed to allow an easy migration and are ideal for industrial applications.

• EMC/EMI performance, ideal for applications in noisy environments
• watchdog timer (COP module) with an independent clock and cyclic redundancy check (CRC) add additional system security in noisy environments
• active power-on reset, low voltage detection and low voltage warning protect against system failure
• designed to help improve performance in motor control applications and, at the same time, reduce external components
• 5.5V to 2.7V operation
• on-chip timers and analog-to-digital converter (ADC) which make Flexis AC ideal for basic motor control techniques
• the AC256 also features a CAN bus for network connectivity. A Cycle Redundancy Check (CRC) engine adds additional security to this protocol allowing for faster testing of flash memory

CodeWarrior Development Studio V6.2

Freescale’s CodeWarrior Development Studio for Microcontrollers V6.2 is an integrated tool suite designed to re-target the applications in just few mouse clicks. If you need to switch to another MCU inside the Freescale controller continuum, you can do it through the MCU Change Wizard. With it you have to select a new microcontroller (either from the same or from a different architecture) and the default connection; after that, CodeWarrior automatically reconfigures the application for the new MCU, selecting the correct build tools (compiler, assembler, linker), and the appropriate support files (header files, libraries and linker files). The V1 ColdFire compiler has also a feature which flags code that needs to be manually inspected and ported (assembly code, interrupt service routines).

Reference
The Controller Continuum

Read the Italian version: Freescale Flexis: la migrazione con il Controller Continuum

CONTACT REQUEST
If you want to know more about this Freescale product, please submit your request to Arrow Italy using this form.

NOTE: this form is valid ONLY for Companies or Customers based in Italy and working in the Italian area.