Scanboard is a tcl proc within the IDcode.tcl script that can be used as a quick sanity check for basic JTAG connectivity. This routine will return the JTAG ID codes for devices on the scanchain and if they are known Freescale devices (at the time the script was last updated) the core indexes will also be displayed for CodeWarrior project configuration. IDcode.tcl is included automatically during the CodeWarrior installation but updates may be available.   This script is executed within the CodeWarrior Connection Server (CCS) and not the CodeWarrior IDE itself where ccs is the conduit that the CodeWarrior Debugger talks to the TAP hardware. CCS can also be used standalone but this is not a supported mode and the use of it is not documented.   On a windows machine start ccs via the Start menu for the CodeWarrior installation you wish to use.   i.e. Start → All Programs → Freescale CodeWarrior →CW for Power Architecture v10.2.1→ CodeWarrior Connection Server   CCS starts iconized in the task bar so double click on the icon to display the ccs console window   On a Linux machine start ccs manually via the ccs executable location within the CodeWarrior installation directory ($CW_INSTALLDIR)/PA/ccs/bin/ccs   i.e. /usr/local/Freescale/CodeWarrior_PA_10.2.1/PA/ccs/bin/ccs Once the CCS console is available the IDcode.tcl file must be brought into the tcl environment via the source command. Beware that on a Linux system the file name is case sensitive.   % source IDcode.tcl   The script will automatically query the host system to determine if there are any available CodeWarriorTAP or USBTAP devices connected via USB which can be used for a remote connection. Specify the connection option that is attached to the target system. For example to configure the connection to be a CodeWarriorTAP on the network select 2 and then enter the IP address or the CodeWarriorTAP name if it is in the host table or can be found within the DNS tables.   It is also possible to predefine custom remote connections via the DefinedCCSConnections.tcl located within the …/ccs/bin directory as well. See this file for details. Once the remote connection has been specified the script will the automatically execute the scanboard proc and attempt to read back the IDcode(s) available on the JTAG scanchain.     In this example the CodeWarriorTAP is connected to a system that has a T4240 processor and displays the IDcode for this device. If there had been multiple processors available on the scan chain each device would have been identified and displayed.

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  

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  

Hey there! Are you familiar with this device shown on top? If you find it similar to the CodeWarrior TAP probe then you are ringing the right bells.   The magic thing of this innovative device is that you can debug systems remotely or more effectively share a single system with multiple developers. When a shared system is not needed, CodeWarrior TAP connects directly to the developer’s workstation with a single USB cable. Power is supplied by the USB port so that no additional cables are required!   This means that the TAP also enables Freescale target system debugging via a standard debug port (usually JTAG) while being connected to your workstation via Ethernet or USB. For this reason this device can also be found under the name of probe, JTAG probe, JTAG emulator or target probe.   These are some of the great features offered by the TAP: Allows either USB or Ethernet (10/100 ) host connection for the developer workstation USB powered, even when using Ethernet Low cost removable probe tips sold separately Supports debugging via JTAG interface Automatically supports system voltage levels from 1.2 to 3.3 Supports all available core speeds and voltages for supported Freescale processors As a convenience feature, the CodeWarrior can connect to a target systems serial port allowing telnet access to a remotely located system and control of the U-boot program.   Keep finding more features and applications within the Fact Sheet If you'd like to dig further into the TAP world, you can also find The User Guide equally useful!      Please note that this device is not up for sale (just yet!). Regardless, Freescale is accepting pre-orders for CodeWarrior TAP now with shipments planned in late October, and DebuggerGuys will keep you informed on this! Don't hesitate on asking beyond!      

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