From your perspective, a CodeWarrior compiler is a single program. Internally, however, a CodeWarrior compiler has two parts: • The front-end, shared by all CodeWarrior compilers, translates human-readable source code into a platform-independent intermediate representation of the program being compiled • The back-end, customized to generate software for a target platform, converts the intermediate representation into object code containing data and native instructions for the target processor A CodeWarrior compiler coordinates its front-end and back-end to translate source code into object code in several steps: • Configure settings requested from the compiler to the CodeWarrior IDE or passed to the linker from the command-line • Translate human-readable source code into an intermediate representation • Optionally output symbolic debugging information • Optimize the intermediate representation • Convert the intermediate representation to native object code • Optimize the native object code • Output the native, optimized object code   A linker combines and arranges the object code in libraries and object code generated by compilers and assemblers into a single file or image, ready to execute on the target platform. The CodeWarrior linker builds an executable image in several steps: • Configure settings requested from the linker to the CodeWarrior IDE or passed to the linker from the command-line • Read settings from a linker control file • Read object code • Search for and ignore unused objects (“deadstripping”) • Build and output the executable file • Optionally output a map file   You might think these are real hard to cambine and put together to get something to work. If you do think that, it's easier than it looks! I found this reference manual at Freescale web page describing how to use the CodeWarrior compiler and linker tools to build software.   As a little introduction, let me explain that CodeWarrior build tools are programs that translate source code into object code then organize that object code to create a program that is ready to execute; CodeWarrior often run on a different platform than the programs they generate, meaning, not the host platform but the target platform. The linker now comes into our lives to pull our code off! Great isn't it? Come on, take a look at it! CodeWarrior build Tools reference

Did you know that the CodeWarrior IDE includes assemblers that support several specific processors? Well, it does, and for you, codewarrior programmer this is one of its many cool tools to develop great code!   Today I found this manual that helps us out and explains the corresponding assembly-language syntax and IDE settings for these assemblers, in this case, thesyntax for assembly-language statements that the CodeWarrior assemblers use.   These explanations not only cover simple statements, they also include macros and directives!   You might be thinking, "dude, all the assemblers share the same basic assembly-language syntax!". I won't argue that, it's true, but instruction mnemonics and register names are different for each target processor.   To get the most from this manual, you should be familiar with assembly language and with your target processor, so I'd recommend you to start getting into this whole low-level programming style!   Unless otherwise stated, all the information in this manual applies to all the assemblers, enjoy!   CodeWarrior Development Studio for Microcontrollers V10.x ColdFire Assembler Reference Manual

This document describes two sets of options and pragmas that can be used with the CodeWarrior tools to produce optimal code for the HCS08 cores. One set optimizes the size of the code; another set optimizes the execution speed.   You can use the build tools options and pragmas described in this document for optimal performance, but the build tools settings must be set according to the application being developed. Don't worry, DebuggerGuys provide you with app notes like this to make the job quickly and easy! Optimal Performance on HCS08 Cores (For more information on the HCS08 Compiler, refer to CodeWarrior Development Studio for Microcontrollers V10.x HC(S)08 web page.)  

Working with ColdFire Architectures for CodeWarrior is really simple and very useful. One little problem that many people has run into, is the relocation of code and data within the MCUs that are being used.   Maybe this will help those who have that issue, the Document I recently found explains the solution I now present.   It provides guidance for relocating code and data within the Microcontroller memory map. It also explains how to create new memory segments and sections by editing the CodeWarrior Linker Command File (LCF) for ColdFire Architectures.   The Linker Command File (LCF) along with other compiler directives, places pieces of code and data into RAM and ROM. You can do this by creating specific sections in the LCF and then matching them to the source code using pragma directives.   Other than making a program file from your project's object files, the linker has several extended functions for manipulating program code in different ways. You can access these functions through commands in the linker command file (LCF).   Linker command files consist of three kinds of segments, which must be in this order: • A memory segment, which begins with the MEMORY{} directive, • An optional closure segment, which begins with the FORCE_ACTIVE{}, KEEP_SECTION{}, or REF_INCLUDE{} directives, and • A sections segment, which begins with the SECTIONS{} directive.   LCF only gets more interesting, so get the Document read now!

To start expanding horizons in CodeWarrior, a great portfolio to use is definetely ColdFire, which houses 32-bit MCUs solutions.   Enabled by a vast ecosystem of development tools and design resources, development on 32-bit gets as easy as it can be!   After having the proper guidance on ColdFire projects, one of the most important things to do is to optimize devices as for speed and size. Not saying that it is completely necessary, but if you already have it, why not using it?   The following documentation is a complete guide to configure compiler options for optimal performance of ColdFire devices, and provides two sets of options to do this: One set optimizes speed; Another set optimizes code size.   Besides, the document contains two main forms of pulling this optimizations off: • MCU 10.x Eclipse IDE • Command Line   Both ways are functional if you want to configure compiler options for speed or size, it's up to you!   It's easily and quickly done, get a try of the application note here! Configuration

CodeWarrior it's constantly updating and optimizing the way everything gets together to pull great things off. In this occasion I found some features updated within Processor Expert's Service Pack, and more specifically, for MCU v10.2.   The update is now available on Freescale's webpage, and the preview shows a list of derivatives that support Processor Expert, such as:   F84441 MC56F84442 MC56F84451 MC56F84452 MC56F84462 MC56F84540 MC56F84543 MC56F84550   And many,  m a n y  more!   In order for this Service Pack to work well, you must count with an update of CodeWarrior for MCU v10.2, which can be also found on Freescale's webpage ready to be downloaded.   Give it a try already! Updates here!

I am working on a project in which I decided to use ColdFire Architectures , but within the classical view of CW. Luckily, there is another version of this document in which the conversion of ColdFire projects to CW Development Studio is also shown in a brief and easy way!   It can be read in the introductory part of the document: "This application note explains how to convert a ColdFire project created in CodeWarrior Development Studio for Microcontrollers V6.2 or CodeWarrior Development Studio for ColdFire Architectures V7.1 to CodeWarrior Development Studio for Microcontrollers V10.0."   I'll admit it was a thrill finding this document, I hope it is of great help for you as it was for me! And if you're not into CodeWarrior development tools, I don't know what you're waiting for!   Converting ColdFire Projects to CodeWarrior Development Studio for Microcontrollers V10.0  

The rumors say that CodeWarrior (CW) can be turn into a faster and lighter tool to get optimal performance on some micros and processors. Such is the case of Power Architectures for e200 core. And guess what! Rumors are true and completely functional.   There is a document explaining how to make CW development suites faster and lighter, specifiying step by step the process to rock on programming power architecture features.   This document provides the two sets of options to produce optimal code generation. One set optimizes for speed; another set optimizes for size. You can choose from one of these or apply them both, getting a whole new experience on programming with this useful app note. Are you trying it already? CodeWarrior Build Tools Options for Optimal Performance on the Power Architecture® e200 Core  

In some of the post I've talked about the many advantages that the combination CodeWarrior-Eclipse can bring up. One of those was the installation on service Packs in a friendlier way than when it's done with the classical view of CodeWarrior. That is why I introduce today the Installing Service Pack for CodeWarrior Tools Quick Start   This Quick Start, in case you are choosing the hard and equally great way to do your own thing with CodeWarrior, it explains how to install a service pack or an update for your classical version of the software running on the Windows platform.   It shows step by step how to do this manually and correctly, preventing you from having an IDE full of stuff you don't even want to use.

CodeWarrior Development Studio for StarCore DSP Architectures Quick Start for the Windows® Edition   The CodeWarrior software it's a very resourceful tool to program a wide variety of MCUs and Processors, and its flexibility makes it installable almost in any operative System. This Quick Start explains how to install the CodeWarrior software on a Windows PC, for example.   Also, the document explains how to use this software to create, build, and debug a simple StarCore DSP project.   In the procedures that are explained within this document, advanced users can use numbered steps. But don't feel bad, novices, there are plenty of detailed instructions that can be easily followed and understood by anyone, provided by substeps.   Enjoy and start programming with CodeWarrior on your PC!

  Today I woke up with the inquiry-ish mood, so I would like to make you some questions, dear reader...ready?   So, you've been working on CodeWarrior Development Tools? Nice! I've become really close with this developing tool due to the major benefits that it's portfolio brings to the developers' community.   Have you experienced any trouble finding .bins or actualizing updates manually? If the answer is "yes", well, me too! Sometimes it's kinda difficult getting to know IDEs completely or finding out all the features that are contained within them.   Did you know that CodeWarrior can be turned into a more graphical coding environment? If the answer is "no", let me tell you there is a way! And a pretty easy one...   If I told you CodeWarrior and Eclipse get together to empower developing tasks...? Yes indeed, they can be merged and they'd easy things up!   Why would I like to merge CodeWarrior and Eclipse features? Basicly, because the classical IDE provided by CodeWarrior turns out to be very manual when it comes to updates; besides, whenever you decide to search for an update, you must sync it and organize it all by yourself...and I know it might not be that hard, but it's not funny when you end up with tons of versions for each update.   The marvellous thing of working with CodeWarrior inside Eclipse IDE is that the graphical environment makes it way easier and friendlier for you, for us developers, and there is no need to search for updates or even trying to get the code segments when working with Processor Expert, for example, it is all viasually arranged and set for you to just have a blast programming.   This time I'll attach the Quick Starts of the CodeWarrior Project Importer, where you can find all the info you need to start using CodeWarrior tools from Eclipse IDE.   Amazing thing, have fun!

The CodeWarrior Ethernet TAP probe is a tool that helps you develop and debug a number of processors and microcontrollers.   The Ethernet TAP probe uses advanced emulation technology to provide control of and visibility into your target system. Combined with a host debugger, it speeds the debugging process by letting you interactively control and examine the state of your target system.   The Ethernet TAP probe has these features: • Supports the following systems: PowerPC™ processors, StarCore processors, ColdFire® processors, 56800 Hybrid Controllers (processors and microcontrollers), ARM® processors, and RCF base-band controllers. (All products reference at Freescale web page!) • Supports all CPU core speeds. • Lets you control and debug software running in-target, with minimal intrusion into target system operation. • Lets you debug code in cache, ROM, RAM, and flash memory. • Provides high performance: – Split-second single-step execution. – Capable of download speeds greater than 12 MB per minute from host to target system.   ...and many more of them! Get it updated today!!!      

This manual explains how to use the CodeWarrior Development Studio tool set to develop software for Freescale StarCore DSP processors. Following now, we present you an overview of this manual as a little introduction to the CodeWarrior development tools and development process.   Before using the CodeWarrior IDE, this targeting manual recommends you to read the developer notes. These notes contain important information about last-minute changes, bug fixes, incompatible elements, or other sections that may not be included within the manual.   Programming for StarCore processors is much like programming for any other CodeWarrior platform target. If you have not used CodeWarrior tools before, start by studying the Eclipse IDE, which is used to host the tools.   If you are an experienced CodeWarrior user, note that the CodeWarrior Development Studio for StarCore DSP Architecture environment uses the Eclipse IDE and the interface is substantially different from the “classic” CodeWarrior IDE. But there's no reason to feel lost! The manual will give you the walk-thrus to become a skilled CodeWarrior programmer!   Start exploring the possibilities with this amazing development tool, what are you waiting for?  

The CodeWarrior USB TAP probe is a cost-effective tool that helps you develop and debug a number of processors and microcontrollers. This chapter introduces you to the USB TAP probe.   The USB TAP probe uses advanced emulation technology to provide control of and visibility into your target system. Combined with the CodeWarrior IDE, the USB TAP speeds the debugging process by letting you interactively control and examine the state of your target system.   The USB TAP probe has these features: • Supports the following systems: Power Architecture processors, StarCore processors, 56800 Hybrid Controllers (processors and microcontrollers), and ColdFire™ processors. • Supports all CPU core speeds. • Lets you control and debug software running in-target, with minimal intrusion into target operation. • Lets you debug code in cache, ROM, RAM, and flash memory. • Provides high performance: – Split-second single-step execution. – Capable of download speeds greater than 12 MB per minute from host to target.   ...and so much more!!! Get into the USB TAP probe world to make it easier and faster! Watch how over here.    

The SmartDSP Operating System (OS) is a Real Time Operating System (RTOS) that, in addition to providing drivers for the MSBA8100 processor, also runs on the following StarCore DSP-based processors: • PSC9131 • MSC815x/MSC825x • MSC814x • MSC812x • MSC8101/3 • MSC711x   The StarCore CodeWarrior (CW) Development Studio includes SmartDSP OS royalty-free source code. Further, SmartDSP OS has a high-level Application Programming Interface (API) that lets users develop integrated applications for StarCore processors.   In SmartDSP OS, most functions are written in ANSI C. However, when needed, Assembly optimizes time-critical functions by maximizing StarCore’s multiple execution units.   Other SmartDSP OS features include the following: • small memory footprint ideal for high-speed StarCore processors • priority-based event-driven scheduling (triggered by user applications or HW) • dual-stack pointer for exception and task handling • inter-task communication using queues, semaphores, and events.   And this is just the beginning of what you can do with SmartDSP OS, get updated here and start coding with DebuggerGuys!

The CodeWarrior Development Studio provides a common interface for developing, debugging, and analyzing your applications. The project-oriented Workbench window provides numerous perspectives containing views, editors, and controls that appear in menus and tool bars. After creating a project, build your application, define a launch configuration, and then wait for data collection and data display.   The StarCore linker is a part of StarCore development tools and generates an executable file for the StarCore family of digital signal processors. In addition, the linker also lets you define a Linker Command File (LCF) that you use to instruct the linker to store different parts of the executable file in different areas of the processor address space. Currently, StarCore development tools support two linker versions: • SC100 • SC3000   The SC3000 linker specifically targets SC3850 family of processors. This user guide explains SC3000 linker. For information on SC100 linker, see StarCore SC100 Linker User Guide. What are you waiting for? Amazing features are right here, and  u p d a t e d!!

The StarCore assembly language tools consist of an assembler, a linker, an archiver, and several utilities. With the simulator user guide provided for Freescale's DSP (Digital Signal Processors), it's possible for us CodeWarrior users to know which are the software simulation models released with CW Development Studio for StarCore Architecture.   This guide contains a list of simulator models supported by DSP, • Instruction Set Simulators (ISS) • Performance Accurate Simulators (PACC) • Instruction-accurate ISS • Unified simulators   It also contains the requirements needed to launch the simulator system, and of course, all the instructions to pull the simulation off! Take a look at it, it's great the amount of things you can do with this! CodeWarrior Development Studio for StarCore DSP Architectures Simulator User Guide

The CodeWarrior Development Studio provides a common interface for developing, debugging, and analyzing your applications. The project-oriented Workbench window provides numerous perspectives containing views, editors, and controls that appear in menus and tool bars. After creating a project, build your application, define a launch configuration, and then wait for data collection and data display.   CodeWarrior Profiling and Analysis Tools provide visibility into an application as it runs on the simulator and hardware. This visibility can help you understand how your application runs, as well as identify operational problems.   The CodeWarrior Profiling and Analysis tool set to develop software for Freescale StarCore DSP processors make it easy to collect the data. The following are the basic features of this tool:   • The basic setup can be done using the Trace and Profile tab in the Debug launch configuration • The advanced setup can be done using the Advanced Settings panel; complex configurations can be defined for the Debug and Profiling Unit (DPU), Virtual Trace buffer (VTB), and On Chip Emulator (OCE) • Data files can be shared between teams • Fast trace collection through High Speed Simultaneous Transfer (HSST) and SmartDSP HEAT (Host Exchange over Asynchronous Transfer) • Displays trace buffer content on Attach to Process • and many  m a n y   more! Get the updates of this guide here!

The CodeWarrior  Development Studio provides a common interface for developing, debugging, and analyzing your applications. The project-oriented Workbench window provides numerous perspectives containing views, editors, and controls that appear in menus and tool bars. After creating a project, build your application, define a launch configuration, and then wait for data collection and data display.   The StarCore Linker generates an executable file by combining the object files and libraries specified in your project. Using a linker command file (LCF), you can instruct the linker to store portions of your executable in different areas of memory. The linker relocates and binds symbols to addresses according to the directives in your LCF.   The StarCore linker supports the SC100 and SC3000 architectures, and all Freescale devices based on these architectures, including the SC140 and SC3400 and its variants.   The highlights of the linking process are:      1. Build a map of available memory according to the .memory and .reserve directives defined in the linker command file.      2. Read the input object files and libraries. Combine like-named sections, build the global symbol table, and resolve undefined references.      3. Strip data never used; strip the code of functions never called.      4. Place segments in memory, according to .firstfit, .org, and .segment directives. Place all absolute sections before placing relocatable sections. If any sections are left over after processing the segment directives, place those remaining sections in their own segments on a first-fit basis.      5. Generate any LoadAddr_ symbols for overlays. Check each module’s symbol table to ensure that there are no more undefined references.      6. Process the relocations to resolve external reference values.      7. Write the executable output file.   This and many more features are now updated in the SC100 Linker User Guide, take a look at it and start developing with CodeWarrior!

The StarCore assembly language tools consist of an assembler, a linker, an archiver, and several utilities.   Freescale's DSP (Digital Signal Processors), built on StarCore technology, offer high-performance programmable devices for baseband, aerospace, defense, medical and test and measurement markets. The StarCore DSP portfolio provides customers with fully scalable and flexible solutions to get to market faster. Combine that with the low power and low cost of the StarCore DSPs and they are the ideal solution for your next design.   Today we're bringing up the Assembler User Guide that contains the walk-thrus of StarCore DSP Architectures on CodeWarrior Development Studio. This manual explains the assembly language tools for the StarCore DSP cores. As it is mentioned somewheren within the User Guide, the StarCore assembler architecture is compiler-friendly, so you can combine it with a compiler that generates exceptionally compact code.   With this great advantage, you can write applications in C, for example, yet achieve code density and high performance comparable to that of hand-coded assembly programs!   Get a glance at this manual and start using CodeWarrior for StarCore DSP today!   Don't be afraid and ask any questions to DebuggerGuys