The great thing with CodeWarrior development Suites is that you can develop almost in any programming environment out there, even if it's assembly.   In this occassion, I ran into a Reference Manual regarding a StarCore ABI (Application Binary Interface)   This document defines a set of standards to ensure interoperability between conforming CodeWarrior for StarCore software components, such as, compilers, assemblers, linkers, debuggers, and assembly language code. These standards cover run-time aspects as well as object formats to be used by compatible tool chains from StarCore and third-party tools developers.   A benefit of this standard definition is interoperability of conforming tools so that users can select the best tool for each phase of the application development cycle, rather than being constrained to using an entire tool chain. Another benefit is compatibility of conforming libraries. Us programmers can build compatible binary libraries and assembly code libraries and be assured of their continued compatibility over time.   So if you are ready for a new experience at programming (in case binary interfaces are your thing) start along with this Reference Manual!  

CodeWarrior development suites allow ready access to any or all of the CodeWarrior products contained within each suite, which means you get freedom to design across Freescale's extensive silicon portfolio.   CodeWarrior development tools provide the capabilities required by every engineer in the development cycle, and this suites right here make easier the filter process for you to know which product list meets your needs, 100% flexibility to choose the required purchasing model.   This means you can license the entire portfolio of CodeWarrior tools within the suite you purchase. Each suite also contains all functionality of the products in the suites below it.   Purchasing and accessing these tools now is easier and more affordable!!!       CodeWarrior suites include:   •           CodeWarrior Professional Suite: Fullfeatured development suites •           CodeWarrior Standard Suite: Selectively featured development suites •           CodeWarrior Basic Suite: Compiler upgrades to special editions, Linux applications editions and flash programmers •           CodeWarrior Special Editions: Featurelimited development tools   Flexible purchasing models are shown here! And you can also check the quick reference guide for further info!

Recently I have two customers asking me same questions – How to use S12Z Burner under CW10 for S12Z. Unlikely CW10 for S08, S12Z build process does not use the Burner to generate S-Record file. By default, after a successfully build, S12Z build tool chain generates elf file only. The Burner panel has remained as part of the S12Z properties since the build tools configuration panels were imported from S08 build tools. Thus even users configure it, it doesn’t generate bbl file and s19/hex/bin files. Fortunately we have workaround to integrate burner tool into CodeWarrior10 post build steps. doc and demo code is attached. We can also refer article from Erich. S-Record, Intel Hex and Binary Files | MCU on Eclipse 

The StarCore C/C++ compiler, in conjunction with the assembler and the linker, generates binaries for the StarCore family of DSP. 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 StarCore C/C++ Compiler User Guide, which explains how to operate this compiler. In addition, thedocument describes you how to optimize C/C++ source code to let the compiler take full advantage of the StarCore processor’s advanced hardware. Awesome, isn't it? Multitask documentation like this make it easier and better to start programming! Get a glance at this manual and start using CodeWarrior for StarCore DSP today! Don't be afraid and ask any questions to DebuggerGuys

  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 content is to tell user how to add nand flash(MT29F2G08ABBDA) support in CW 10.3.

You remember the previous post regarding the new awesome TAP for CodeWarrior applications?   Today I'd like you to meet this device shown up here. Is the CWH-STC-COP-YE, a removable probe tip for StarCore and DSC processors. This probe tip connects your StarCore or DSC processor target system’s ONCE port to the CodeWarrior TAP base unit’s 30-pin target connector.   And of course this tip is compatible with the CodeWarrior TAP previously mentioned (CWH-CTP-BASE-HE). As a matter fact, the base unit doesn't come with a probe tip, so it is necessary to acquire one of the tips available to debug your device. Check out the main features!   Features Removable probe tip Low-cost and economical to order several spares Allows base unit to work with several different target types System Requirements StarCore or DSC target system with ONCE header CodeWarrior TAP  

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!!

We talked of RTOS a little while ago. This time it's turn for The SmartDSP Operating System (OS), and more specifficly, SmartDSP API.   But, what is the SmartDSP OS? It 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: MSC815x MSC825x PSC9131   The StarCore CodeWarrior (CW) Development Studio includes SmartDSP OS royaltyfree source code. Further, SmartDSP OS has a high-level Application Programming Interface (API) that lets users develop integrated applications for StarCore processors. This Reference Manual documents SmartDSP OS API.   Having this API updated and available for processors MSC815x/MSC825x/PSC9131, possibilities of coding within CodeWarrior features become even broader. Start trying it up now!!!

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!!!      

If you recently acquired the CodeWarrior Development Suite, you'll find this document very useful; it provides access and technical support to a multitude of CodeWarrior products.   This quick start also explains how to register your CodeWarrior Development Suite (Section A). Section Bexplains how to activate and install one of your products. Section C describes other items that come with your CodeWarrior Development Suite, and Section D discusses the available purchase options. Section E contains the Technical Support Certificate. As you may not have access to fully license all the CodeWarrior products, keep the following Web link handy, as it lists all the products in the differently priced levels of the CodeWarrior Development Suites (Basic, Standard and Professional). www.freescale.com/CodeWarriorSuites Check it out now! CodeWarrior Development Suite Quick Start

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  

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

How to log an issue in Case system instead CRM (Service request)?     After the merge of Freescale and NXP, technical support cases are answered in a different system. To submit your case into the new system, please follow below steps:    1) Go to http://www.nxp.com/support/sales-and-support:SUPPORTHOME.    2) On the bottom of the page under Submit New Issues, click Hardware & Software.    3) Register with your business email to access NXP technical online support.    4) A verification email will be sent to your account. Click the link embedded in that email to verify your access.    5) On the NXP online support page, select Contact Support from the top menu and click “submit a new case” to start the process.   Attached you will find a video explaining the process to follow.

This project is an example of using the DSC CodeWarrior linker to place code in a different area of memory.  In this case, the FlexNVM flash block is used. The example uses three different methods in the linker command file to force specific code to a different memory segment, see examples below.  For more information on the linker syntax, see the manual installed with CodeWarrior at \CW MCU v10.6.x\MCU\Help\PDF\MCU_DSC_Compiler.pdf     This project was developed for the TWR-56F8400 Tower development board, using CodeWarrior for Microcontrollers v10.6.6.  The project was created using Processor Expert, and blinks an LED using the PIT timer interrupt.     The linker command file is located at \Project_Settings\Linker_Files\FLASH_SDM.cmd.Here are the key changes to the project:     MEMORY {         # Added .p_FlexNVM memory segment         .p_FlexNVM(RWX) : ORIGIN = 0x00068000, LENGTH = 0x00004000 }     # Added .FlexNVM_Code memory section .FlexNVM_Code : {   TI1_c.obj (.text) # Place whole source file in this section   OBJECT (FPE_low_level_init, cpu_c.obj) # Place individual function in this section   * (FlexNVM_code.text) # Place from section defined in source code, see main.c     } > .p_FlexNVM     and in main.c: #pragma define_section FlexNVM_code "FlexNVM_code.text"  RX #pragma section FlexNVM_code begin void main(void) {   /* Write your code here */ } #pragma section FlexNVM_code end

This document shows a general way how to preserve memory range using target task in CW10.6.   I am using k64 freedom board and Segger J-link in my project as an example. K64 freedom board use MK64FN1M0 MCU which has 1 M size flash.  In my project I divide the flash into two areas in the link file as below:   /* Specify the memory areas */ MEMORY { m_interrupts       (rx) : ORIGIN = 0x00000000, LENGTH = 0x198 m_cfmprotrom       (rx) : ORIGIN = 0x00000400, LENGTH = 0x10 m_text             (rx) : ORIGIN = 0x00000800, LENGTH = 512K m_text2            (rx) : ORIGIN = 0x00080800, LENGTH = 512K - 0x800 m_data         (rwx) : ORIGIN = 0x1FFF0000, LENGTH = 64K                  /* Lower SRAM */ m_data2        (rwx) : ORIGIN = 0x20000000, LENGTH = 192K                 /* Upper SRAM */ } m_text2 is the memory area that I am trying to keep it from being erased while downloading the application to m_text memory area. Here are the steps to do this using target task in CW10.6. Add a target task view by clicking Window -> Show View -> other from menu bar, then select Debug -> Target Tasks view in the popup window. From the Target Tasks view, select “Import” from the context menu. Then select the flash (.xml) file for your target device. In this case I need to select MK64FN1M0.xml file. After that you will see a “MK64FN1M0” task in the list. Double click the task name, you will see there are two actions (“Erase” and “Program and Verify”) in the “Flash Programmer Actions” view.   The default Erase action will mass erase all flash, so I remove this action by unchecking the “Erase” action. I can add erase action in “Program and Verify” action later. Double click the “Program and Verify” action. In the popup dialog, check “Erase sectors before program” option. Check “Restrict to Addresses in this Range” option, and then specify the address range you want to program. The data/code out of this range will be preserved (will not be erased or changed). Click “Update Program Action” button to update the settings of this action. Move to Debug configurations window by clicking Run -> Debug configurations from Menu bar. Select a debug configuration, in this case I select the run configuration for Segger J-Link. Select Download tab which is under Debugger tab. By default, Standard Download will be executed and all the flash will be erased. As I am going to execute target task in this case, so uncheck “Perform Standard Download” and then check “Execute Tasks”. Click “Add” button to add a task. In this case I add K64F1M0M12 task which I created in previous step in target task view. Click “Debug” button, the application will be downloaded to flash but preserved area which was not specified in restrict flash range will not be erased. You can check this from memory view.   With the above steps, you can preserve a specified flash range while downloading application. I am using Segger J-link in my project as an example and the steps also work for other tools like P&E Multilink and USB Tap.

How to install and use eGit plug-in in CodeWarrior

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.)  

If you mix the great new TAP kit for CodeWarrior with the right Tip, the possibilities of debugging your devices become bigger and more powerful. In this occasion I will show you one more removable probe Tip: the CWH-CTP-BDM-YE, meant for ColdFire processors connects your ColdFire microprocessor/microcontroller target system’s BDM port to the CodeWarrior TAP base unit’s 30-pin target connector.   The compatibility of this Tip and the CodeWarrior TAP CWH-CTP-BASE-HE base unit empowers your creations and helps you lowering costs. Note this Tip is not included within the TAP kit. Check out the cool features:   Features Removable probe tip Low cost and economical to order several spares Allows base unit to work with several different target types   System Requirements ColdFire based target system with BDM header CodeWarrior TAP  

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