The Road to CCSv4 Status Update - Texas Instruments

The Road to CCSv4
   Status Update

Code Composer Studio v4 Summary
•   What is it?
     –   Major upgrade to CCS
     –   Major architectural changes
     –   Based on Eclipse open source software framework
     –   New registration/licensing/updating mechanism and model
•   Why Eclipse?
     –   Significant momentum in the embedded industry
     –   Excellent software architecture
     –   Ability to leverage the work of others
     –   Cross-platform support (i.e. Windows & Linux)
     –   Wide selection of 3rd party plug-ins available
•   When?
     – Early Adopter releases available now
     – Mass-market availability early 2009
•   How?
     – Restructuring of our debug stack
     – Porting of existing features to Eclipse
     – Taking the time to make sure migration will be as smooth as possible

Eclipse Background
       •   Eclipse
            –   Originally IBM’s Java Development Environment
            –   Open platform for tool integration built by an open community of tool providers
            –   Operates under a open source paradigm
            –   Universal platform for tools integration
            –   Multi-language, multi-platform and multi-vendor environment
            –   Excellent plug-in framework
       •   Governed by Eclipse Public License (EPL)
            –   Royalty free source code
            –   World wide redistribution rights
            –   Enables you to sell components & products
            –   If you modify any source governed by EPL and you need to make the source
                available
       •   Eclipse Foundation
            – The Eclipse Foundation is a non-profit corporation formed to advance the
              creation, evolution, promotion, and support of the Eclipse Platform and to cultivate
              both an open source community and an ecosystem of complementary products,
              capabilities, and services.
       •   Key members
            – IBM/Rational, QNX, WindRiver, Borland, RedHat, MontaVista, Texas Instruments

jes

CCS Vs. CCE
• Code Composer Studio
  – Our main product brand.
• Code Composer Essentials
  – Created as we had to develop a new product for
    MSP430
  – Has a subset of the features of CCS
  – This brand goes away with CCSv4 when all ISAs are
    supported by the same baseline product.
  – Still used in some development “project” names, but
    being phased out.

Licensing Summary
• CCSv4 will incorporate FlexNET licensing
   – Licensing and registration system
• Types of licenses
   – Free evaluation tools
       • 30 days built-in, can extend for 90 more by registering
   – Node locked
       • Tied to a MAC address
   – Floating
       • Share licenses amongst a pool of users
• Enforcement strategy
   – In most cases if you have an issue checking out a license CCS will
     just tell you that there was a problem and not prevent you from
     using the tool.

CCSv4 Architecture
                                         Debug Server
                                         Scripting (DSS)
                                              Shell           Shell              Shell
     Eclipse GUI          Console Win.
                                            Scripting       Scripting          Scripting

       CDT (Java)             Rhino (Javascript)         Inline::Java (Perl)    Jacl (Tcl)

    CDI Adapter (Java)                        Debug Server Scripting (Java)

                         DebugEngine (Java Wrapper)

                            DebugServer.DLL (C++)
                                 Emulation/Simulation Drivers

Early Adopter Program
• Purpose:
   – Migrate existing CCS features to an Eclipse based environment
• Strategy:
   – Incremental releases will be developed targeting a specific set of features
   – System test will validate on specific target configurations
• Feedback:
   – We desire the involvement of key customers, TI FAEs and 3rd party
     partners to help us shape CCSv4
   – There are many features to be migrated and thus lots of opportunity to
     make changes to the environment
• Download:
   – https://www-
     a.ti.com/downloads/sds_support/CCSEclipseEarlyAdopterProgram.htm

Call to Action
• The migration of CCS to Eclipse is a major
  change AND a major opportunity
• We want to work closely with our customers and
  partners to ensure that CCSv4 is by far the best
  CCS ever

Backup

CCSv4 Feature Overview
(equivalent to demo)

Target Setup
• Cc_setup is still used in EA2
  – Will be replaced by an Eclipse plug-in
• It now generates an xml file that describes your
  system setup which is read by the debugger

                         SystemSetup.xml

Workspaces
• What are they?
   – A workspace is a folder that contains information relevant to what
     you are working on
• A workspace contains
   – Projects
       • Either physically in the workspace or referenced by the workspace
   – Window and toolbar arrangements
   – Preference settings
• You can have multiple workspaces and switch between
  them
• Automatically saved when you close
• Can be automatically loaded

First Time You Launch CCSv4

• Launch CCS-Eclipse
  – Code Composer Essentials v3.2 shortcut
• Select workspace location

  – Check the box so it doesn’t bug you every time

Welcome Page
• Purpose
   – Introduce you to the product
   – Provide links to documentation, tutorials,
     examples
• Any ideas on what could go on it?
• How to close it?
   – Click on the yellow arrow
• How to access it after closing
   – If it has been open during the current session then there will be
     buttons on the bottom status bar
   – Otherwise to go Help->Welcome

Perspectives
•   Background:
     –   Each Workbench window contains one or more perspectives.
     –   A perspective defines the initial set and layout of views in the Workbench window.
     –   Each perspective provides a set of functionality aimed at accomplishing a specific type of
         task or works with specific types of resources.
•   As you work in the Workbench, you will probably switch perspectives frequently
•   Customization
     –   Perspectives control what appears in certain menus and toolbars
     –   They define visible action sets, which you can change to customize a perspective
     –   You can save a perspective that you build in this manner, making your own custom
         perspective that you can open again later.
•   Default perspectives in CCS-Eclipse
     –   C/C++: Editing and building
     –   Debug: Debugging your programs
•   You can use the General > Perspectives preference page to open perspectives in
    the same window or in a new window
     –   By default opening a new perspective will switch the perspective but you can change this so
         that it opens a new workbench window for the perspective
                     Open new perspective            Switch to the debug perspective

                                      Current perspective

Window Types

                                                                                                 Editor:
                                                                                              Only editor
                                                                                              windows are
                                                                                               part of this
                                                                                                 group

                                                                                              Tab Group:
                                                                                           Several windows
                                                                                           grouped together

Fast view: Hidden until you click on the button to                    Detached:
 restore them. Click on another window to hide.      Like having float in main window off in CCS

Windowing tips
• Double-clicking on the title bar of a window will
  maximize the window
    – Double-clicking again will restore it to its previous size
• Fast-view windows are great for windows you
  use infrequently but need a lot of space when
  you do use them
• The window that has focus is indicated by a blue
  border and heading

Current window

Customizing Perspectives

• You can customize the menu items and toolbars
  in your perspective
• Commands
  – Controls menus & toolbars
• Shortcuts
  – Controls special sub-menus
    (new, show view…)

Accessing Views

• To open a new view go to the Windows -> Show
  View Menu
  – Common views for the
    current perspective
  – Recently opened views
• To access views that are
  not listed select Other…

Help
• The help system is not yet complete but there are
  help topics available for most views
• You can access the help table of contents from
  the main Help menu however the best way to
  access help for a specific view is to open it and
  then hit F1
  – The help may be part of any number of tools packages
    C++, Java, custom TI… so F1 can be the best way to
    find it

Projects

• 2 key types
  – Managed Build Projects
  – Standard Make Projects
• Managed Build Project
  – Similar to CCS PJT files
  – Project files are based on makefiles
• Standard Make Project
  – You specify the build commands to run
  – Typically used when building with custom makefiles
  – Can also be used to build with CCS PJT files

Files in a Project

• By default all files in the project directory are in
  the project
• When you “Add” files to the project it copies them
  into the project directory
• When you “Link” files to the project it just
  references the files and leaves them in their
  original location
• You can create folders in the project

C/C++ Projects View
• Used for navigating the projects
• Folder structure represents
  directory structure of project
  – Dragging files between folders will
    move them
• “Includes” displays header
  search paths
• Expand source files to show
  source scan information
• Context menu provides access
  to project operations

Problems View
• Summarizes all errors, warnings and remarks found
  during a build
   – Based on error parsers associated with the project
• Works for both Managed Build and Standard Make
  projects
• Double clicking takes you to the problem
• Problems are also indicated in source selection margin
  and outline view

Advanced Editor Features
• Code Completion
   –   Complete word
   –   Auto-member information
   –   Auto-parameter information
   –   …
• Navigation
   –   Back/Forward buttons
   –   Back to last edit button
   –   Go to definition
   –   Go to declaration
• Show line numbers
• Code Folding
   – Collapse functions

Outline View
• Shows source scan information
  for the current source file in the
  editor
• Great for navigating with in a file
• For C it shows
   –   Functions
   –   Include files
   –   Global variables
   –   Types

Local History
• Eclipse keeps a local history of source changes
• You can compare your current source file
  against any previous version or replace it with
  any previous version

Refactoring

• For C/C++ refactoring support is limited to
  renaming
• Instead of doing a find/replace in files you can
  identify a function or variable that you want to
  rename and it will automatically do this for you
  – Only valid instances are replaced
     • i.e. it will not replace an instance of the name that is part of
       another name…
• To use simply right click on a function in the
  source window, outline view or C/C++ projects
  view and select Refactor -> Rename

Edit Markers
• If you have the line number column on it also
  indicates changes in your source file since
  your last save
          Modified lines

          Deleted lines

          Inserted lines

Tasks
• Your own TODO list
  – Allows you to keep track of things to do
• Associate tasks with source lines
  – Add a task by right clicking in the editor left selection
    margin
• Tasks view shows tasks that are contained in
  your workspace

Launching the Debugger
• Debug Active Project
   – Automated debugger launch
       • Connects to appropriate target in your system setup
       • Loads program
       • Runs to main (optional)
• Launch TI Debugger              Debug Active Project   Launch TI Debugger   History

   – Manual debugger launch (no other actions performed)
• Automatic perspective switch
   – CCS-Eclipse switches to the debug perspective when the
     debugger is launched (configurable)
• Connect/Disconnect
   – Much like in CCSv3.3
   – Select the device to perform the action on and then click the
     connect/disconnect button

Debug View
• This is your main debug control window
• Used for
  – Execution control (run, halt, step, restart, go-main)
     • These buttons are being added to the main toolbar
  – Reset
  – Callstack
  – Selecting the current debug context
     • i.e. what should each of the other views be showing information
       for (CPU, thread, frame in callstack)

Disassembly View

Enter starting address or expression   Switch between ASM only and mixed-mode

                                                            Read next or previous block of memory

                                                             Scroll within current block

Watching Variables

• CCSv3.x
  – Locals/watch tabs
• CCSv4
  – Variables View
  – Expressions View

Variables view
•    Equivalent to the locals tab on the CCS Watch Window
•    By default shows local variables in the current stack frame
•    You can optionally add global variables
•    Several options on context menu

    Click to add global variables

Expressions View
• Equivalent to the Watch tabs on the CCS Watch
  Window
• Will be updated to use the same control as the
  Variables view
• To edit an expression or change the value of a
  variable you need to use the context menu

Registers View
• Uses the same register information as CCSv3.3
   – XML register definition files
       • Register groups
       • Bitfields
• Create your own register groups via the context menu

Memory View
• Renderings
    – Basically you can have different views of the same memory (hex,
      ascii…)
                                      Open a new memory view

 Enter expression for start address   Page       Refresh       Create a new rendering

Breakpoints View
• Equivalent to the breakpoint manager
• Supports advanced breakpoints
  – Specific device support being added

Modules View
• Shows currently loaded symbol files
• Used for symbol file management
                                  Load program   Load Symbols   Add Symbols

      When loading or adding symbols
         you can specify offsets

Console View
• Multiple contexts
   – When the CPU is selected it operates as a GEL command
     interface to the debugger
   – When CIO is selected it shows CIO output
   – Automatically switches contexts
      • Can use the “pin” option to prevent this
• You can open multiple console windows
   – Printfs in one and command interface in another

Source Search Paths
• If you have a managed build project the source
  files are in it and we know how to find them
• However if you are using a standard make project
  or no project at all that is not always the case
• Thus just like in CCSv3.3 where you setup the
  source search directories CCS-Eclipse has a
  similar capability

Source Search Paths per Launch
•   If the debugger can’t find a source file you will see something like this:

•   You can just click on the “Edit Source Lookup Path” button

•   Then specify the path to
    search

Source Search Paths per Launch (2)

• This will store the path in the debug launch
  session but it is not shared between sessions
  – To re-launch the same session you can click on the
    arrow beside the debug icon or when a session that is
    named the same is launched it will use the paths

Global Source Lookup Paths
• You can setup source lookup
  paths that are shared
  between launch sessions
• Window->Preferences
• Select C/C++->Debug-
  >Common Source Lookup
  Path
• Paths setup for a specific
  launch will take precedence
  over the common paths

Search Paths for a Symbol File
• You can also setup search paths based on a .out
  file so that every time you load the .out file it will
  use those paths