What's New in C166 Version 5.00

• [µVision3 - Integrated New IDE]
  µVision3 is now a part of all C166 kits. Projects created with µVision3 and µVision2 are fully interchangable. You may use whichever IDE you like. µVision3 adds many new features such as Source Outlining, Function Navigation, Template Editor, Incremental Search, Configuration Wizard, and Logic Analyzer.
  
  µVision3 adds support for CVS Software Version Control System which is an Open Source version control system.
  
  Refer to the µVision3 Quick Start Brochure for more information.
• [µVision3 - Added XC16x Device Simulation and Target Dialogs]
  Device simulation and target peripheral dialogs (with the exception of CAPCOM6) have been added for the XC161, XC164, and XC167 devices. CAPCOM6 is planned for release in March 2004.
• [EC++ Compiler]
  The EC++ Compiler is now available in the release version.
• [C166 - Added XLARGE Memory Model]
  Added the XLARGE memory model which stores variables in xhuge memory and functions in far memory. This new memory model allows virtually unlimited memory access. Note that size_t for most library functions is unsigned int which limits the size of a single object to 64KB. However the object itself may reside anywhere in the xhuge memory space.
• [C166 Library - Added Block-Based Memory Allocation Routines]
  New library functions (malloc_b, free_b, calloc_b, realloc_b, init_mempool_b) support block-based memory management of xhuge buffers. These functions return memory blocks that may be accessed with huge or far pointers. They provide efficient addressing for xhuge memory buffers without the memory limitations imposed by huge and far memory objects.
• [C166 Library - Added Thread-safe, Fixed-Block Memory Allocation Routines]
  Added library routines to support memory pools with fixed-size memory blocks. In contrast to the standard memory allocation routines, these routines are reentrant and thread-safe. They may be used without restriction in real-time operating systems like the new Advanced RTX166. You may call them from interrupt routines and from the main function. The following routines are available:
  
  
  • Near Memory Box: _init_boxn, _alloc_boxn, _calloc_boxn, and _free_boxn.
  • Far Memory Box: _init_boxf, _alloc_boxf, _calloc_boxf, and _free_boxf.
  • Huge Memory Box: _init_boxh, _alloc_boxh, _calloc_boxh, and _free_boxh.

  Execution times for these routines are deterministic and are independent of memory pool sizes.

• [MAC Programming: Example Code for Signal Processing]
  Application Note 178 shows how to implement and debug DSP algorithms designed using the MAC instructions of the Infineon XC16x devices. The example code uses in-line assembler and function inlining to obtain maximum performance. Program debugging is performed with the µVision Debugger/Simulator and the new Logic Analyzer function.
  
  The DSP Library from Infineon (using in-line assembly for MAC programming) is now available.
• [MCBXC167 Examples]
  Examples for the MCBXC167 Board are available in the \KEIL\C166\BOARDS\KEIL MCB-XC167 folder. They may be used to demonstrate OCDS debugging with ULINK, PLL configuration, and TwinCAN communication. An Easy Web Server that uses the 10/100bps Ethernet controller on this board is also available.
  
  These examples may be used with user hardware that is based on XC16x devices.
• [C166 Compiler - Improved Function In-Lining]
  Function in-lining has been improved in cases where the __inline function calls other __inline functions. The rules for function in-lining are as follows:
  
  
  1. Function in-lining is performed on an expression statement boundary where the right side operator is a function call. For example:

     z = iFunc (z1, z2)          // in-lined:     first operation is function call
     z = iFunc (z1, z2) * 11     // not in-lined: first operation is multiplication
     z = iFunc (z1, z2) + 2;     // not in-lined: first operation is addition

  2. Expressions with for statements are never in-lined. For example:

     for (z = iFunc (z1, z2) ; z != 0 ; )  {  // call to iFunc never in-lined
       ...
     }

  3. An __inline function with no calls (leaf function) or calls to other leaf functions is in-lined as long as the above rules are fulfilled.

     static __inline int yFunc (int n)  {
       return (n + 10);
     }
      
     static int zFunc (int n)  {
       return (n + 10);
     }
      
     static __inline int iFunc (int i, int y)  {
       i += y;
       i += yFunc (y);      // Note: i += yFunc * zFunc (i): not in-lined
       i *= zFunc (i);
       return (i);
     }
     
     static int z, z1, z2;
     
     void main (void)  {
       z = iFunc (z1, z2);           // in-lined
       z = z2 + iFunc (z1, z2);      // not in-lined
       z = iFunc (z1, z2) * 11;      // not in-lined
     }