description
stringlengths 60k
250k
| abstract
stringlengths 89
21.6k
| description_length
int64 60k
250k
|
|---|---|---|
This application claims priority under 35 USC §119 (e)(1) of Provisional Application Serial No. 60/106,572. filed Nov. 2, 1998.
TECHNICAL FIELD OF THE INVENTION
This invention relates to integrated development tools.
SUMMARY OF THE INVENTION
The present invention provides an integrated development tool.
BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a flow chart illustrating development cycle phases;
FIG. 2 is a block diagram illustrating components of the integrated development tool;
FIG. 3 shows a representative DSP software development flow;
FIG. 4 represents an editor window for viewing C source code with the equivalent assembly instructions shown after the C statements as depicted;
FIG. 5 represents a project file used to build an application;
FIG. 6 is a time line illustrating real-time analysis features of the integrated development tool;
FIG. 7 represents a visual editor for creating and setting properties for run-time objects that will be used by the target application; and
FIG. 8 illustrates a directory of folders for an installed integrated development tool.
DETAILED DESCRIPTION
The integrated development tool of the present invention gives developers of applications for digital signal processor (DSP) chips the ability to develop and analyze embedded real-time software. It provides easy-to-use tools for configuring, building, debugging, tracing, and analyzing programs. It also includes a set of application program interface (API) calls for real-time tasks. The integrated development tool extends basic DSP software tools with an equally essential set of debugging and real-time analysis capabilities. The integrated development tool supports the development cycle phases of design, code & build, debug, and analysis depicted in FIG. 1 .
The integrated development tool includes the following components: DSP Code Generation Tools, Integrated Development Environment, DSP/BIOS plug-ins and API, and RTDX plug-ins, host interface, and API. These components work together as shown in FIG. 2 .
Code Generation Tools
The DSP code generation tools provide the foundation for the development environment provided by the integrated development tool. FIG. 3 shows a representative DSP software development flow. The most common software development path for C language programs is shaded. Other portions are peripheral functions that enhance the development process.
The following list describes the tools shown in FIG. 3 . The C compiler accepts C source code and produces appropriate DSP assembly language source code. The assembler translates assembly language source files into machine language object files. The machine language is based on a common object file format (COFF). The assembly optimizer allows linear assembly code to be written without being concerned with the pipeline structure or with assigning registers. It assigns registers and uses loop optimization to turn linear assembly into highly parallel assembly that takes advantage of software pipelining. The linker combines object files into a single executable object module. As it creates the executable module, it performs relocation and resolves external references. The linker accepts relocatable COFF object files and object libraries as input. The archiver allows collection of a group of files into a single archive file, called a library. The archiver also allows modification of a library by deleting, replacing, extracting, or adding members. The library-build utility may be used to build a customized runtime-support library. The runtime-support libraries contain the ANSI standard runtime—support functions, compiler-utility functions, floating-point arithmetic functions, and C I/O functions that are supported by the compiler. The hex conversion utility converts a COFF object File into TI-Tagged. ASCII-hex, Intel. Motorola-S, or Tektronix object format. The converted file may be downloaded to an EPROM programmer. The cross-reference lister uses object files to produce a cross-reference listing showing symbols, their definitions, and their references in the linked source files.
Integrated Development Environment
The Integrated Development Environment (IDE) is designed to easily edit, build, and debug DSP target programs.
Editing Program Code
The IDE allows you to edit C and assembly source code. You can also view C source code with the equivalent assembly instructions shown after the C statements as depicted in FIG. 4 . The integrated editor provides the following features: highlighting of keywords, comments, and strings in color; marking C blocks in parentheses and braces, finding matching or next parenthesis or brace; increasing and decreasing indentation level, customizable tab stops; find and replace in one or more files, find next and previous, quick search; multiple-action undo and redo; multiple windows and windows with split panes; and context-sensitive help.
Building Applications
Within the IDE, an application may be created by adding files to a project. The project file is used to build the application. Files in a project can include C source files, assembly source files, object files, libraries, linker command files, and include files as depicted in FIG. 5 . An easy-to-use window allows specification of the options to use when compiling, assembling, and linking a project. Using a project, The IDE can create a full build, an incremental build, and can compile individual files. It can also scan files to build a dependency tree for the entire project.
Debugging Applications
The IDE supports the following program debugging features: breakpoints, with a number of stepping options: automatic updates at breakpoints; watched variables; view and edit memory and registers; view call stack; probe points for streaming data and memory snapshots to/from target; graphing of signals on target; profiling of execution statistics; and viewing of disassembled and C instructions executing on target.
DSP/BIOS Plug-ins and API
In addition to the familiar debugging features. The integrated development tool provides support for real-time program analysis. Developers can visually probe, trace, and monitor a DSP application as it runs with minimal impact on the application's real-time performance.
During the analysis phase of the software development cycle, traditional debugging features become ineffective for diagnosing subtle problems that arise from time-dependent interactions. The real-time analysis features of the integrated development tool are important during this development phase. The plug-ins provided with the DSP/BIOS API support real-time analysis as depicted in FIG. 6 . Unlike traditional debugging, which is external to the executing program, these features require the target program to be linked with certain DSP/BIOS API modules.
The DSP/BIOS API provides the following real-time analysis capabilities: a) program tracing by displaying events written to target logs, and reflecting dynamic control flow during program execution; b) performance monitoring by tracking statistics that reflect utilization of target resources, such as processor load and thread timing; and c) file streaming by binding target-resident I/O objects to host files.
The DSP/BIOS API (C or assembly) also provides support for timing measurement, periodic execution of functions, and multi-priority threading and scheduling. These API calls are optimized for use on the target DSP.
In addition to adding DSP/BIOS API calls to a program, the Configuration Tool in the IDE environment may be used to create files that define objects used by the DSP/BIOS API. This also simplifies memory mapping and hardware ISR vector mapping.
Configuring Programs to Use DSP/BIOS
The Configuration Tool has two roles: it sets parameters used by the DSP/BIOS API at run-time, it serves as a visual editor for creating and setting properties for run-time objects that will be used by the target application's DSP/BIOS API calls. These objects include software interrupts, I/O streams, event logs, and more as depicted in FIG. 7 .
Unlike systems that create objects at run-time with API calls that require extra target overhead (especially code space), all DSP/BIOS objects are statically configured and bound into an executable program image. In addition to minimizing the target memory footprint by eliminating run-time code and optimizing internal data structures, this static configuration strategy detects errors earlier by validating object properties before program execution. The Configuration Tool generates several files that will be linked with the code written.
DSP/BIOS API Modules
A program can use one or more of the DSP/BIOS modules as desired. A separate C header file or assembly-macro file for each module allows minimization of the program size overhead in a program that uses DSP/BIOS. The IDE may be used to assemble, compile, and link programs that use the DSP/BIOS API, just as for programs that do not use DSP/BIOS.
The DSP/BIOS API is divided into the modules indicated in Table 1. All the operations within a module begin with the three-letter codes shown here.
TABLE 1
DSP/BIOS modules
CLK:
The on-chip timer module controls the on-chip timer and
provides a logical 32-bit real-time clock with a high-resolution
interrupt rate as short as a single instruction cycle and a low-
resolution interrupt rate as long as several milliseconds or
longer.
HST:
The host input/output module manages “host channel objects,”
which allow an application to stream data between the target
and the host. Host channels are statically configured for input
or output.
HWI:
The hardware interrupt module provides support for hardware
interrupt routines. In the Configuration Tool, functions that will
run when hardware interrupts occur can be assigned.
IDL:
The idle function module manages “idle functions,” which are
run in a loop when the target program has no higher priority
tasks to perform.
LOG:
The log module manages LOG objects, which capture events in
real-time while the target program executes. System logs may be
used or user-defined logs may be created. Messages in these logs
may be viewed in real-time with The integrated development
tool.
MEM:
The memory module allows specification of the memory
segments required to locate the various code and data sections of
a target program.
PIP:
The data pipe module manages data pipes, which are used to
buffer streams of input and output data. These data pipes provide
a consistent software data structure to drive I/O between the DSP
chip and all kinds of real-time peripheral devices.
PRD:
The periodic function module manages periodic objects, which
trigger periodic execution of program functions. The period of
these objects can be controlled by the clock rate maintained by
the CLK module or by regular calls to PRID-tick, usually in
response to hardware interrupts from peripherals that produce
or consume streams of data.
RTDX:
Real-time data exchange manager.
STS:
The statistics module manages “statistics accumulators,” which
store key statistics while a program runs. You can view these
statistics in real-time with The integrated development tool.
SWI:
The software interrupt module manages “software interrupts,”
which are patterned after hardware interrupt service routines
(ISRs). When a target program posts an SWI object with an API
call, the SWI module schedules execution of the corresponding
function. Software interrupts can have up to 15 priority levels;
all levels are below the priority level of hardware ISRs.
TRC:
The trace module manages a set of trace control bits which
control the real-time capture of program information through
event logs and statistics accumulators.
Real-Time Data Exchange (RTDX) Host Interface
In addition to the RTDX API module, RTDX includes a host interface and the IDE plug-ins that allow you to use display and analyze data sent from the target to the host with the RTDX API. You can also use Visual Basic to format and customize the display of data obtained through RTDX.
Third-Party Plug-ins
Third-party software providers can create ActiveX and Wizards plug-ins that complement the functionality of The integrated development tool. A number of third-party plug-ins arc available for a variety of purposes.
The IDE also provides the Go DSP extension language (GEL) language, which allows adding functions to the IDE menus for commonly performed tasks.
Integrated Development Tool Files and Variables
The following sections provide an overview of the folders that contain the integrated development tool files, the types of files you will be using, and environment variables used by the integrated development tool. The installation process creates the subfolders shown in Table 2 within the installation folder where the integrated development tool is installed as depicted in FIG. 8 :
TABLE 2
Subfolders
bin-Contains various utility programs.
cxxxx\bios-Contains files used when building programs that use
the DSP/BIOS API (where cxxx represents a specific DSP numerical
designation).
cxxxx\cc-Contains chip-specific files used by the IDE.
cxxxx\ctools-Contains software development tools.
cxxxx\docs-Contains files for online help and user guides.
cxxxx\drivers-Contains files for various DSP board drivers.
cxxxx\rtdx-Contains files for use with RTDX.
cxxxx\tutorial-Contains the examples.
ccs\bin-Contains program files for the the IDE.
ccs\gel-Contains GEL files for use with the IDE.
ccs\plugins-Contains plug-ins for use with the IDE.
While using The integrated development tool, files have the file name formats listed in Table 3
TABLE 3
File name formats
project.mak-project file used by the IDE to define a project and build
a program
program.c-C program source file(s)
program.asm-assembly program source file(s)
filename.h-header files for C programs, including header files for
DSP/BIOS API modules
filename.lib-library files
project.cmd-linker command files
program.obj-object files compiled or assembled from source files.
program.out-an executable program for the DSP target
(fully compiled, assembled, and linked).
This program may be loaded and run with the IDE.
project.wks-workspace file used by the IDE to store information about
environment settings
program.cdb-configuration files created by the Configuration Tool in
The integrated development tool. These files are used to create or modify
DSP/BIOS objects and their properties. The following files are also
generated when a configuration file is saved for a TMS320C6000 DSP.
programcfg.cmd-linker command file
programcfg.h6x-header file
programcfg.s6x-assembly source file
The installation procedure defines the variables illustrated in Table 4 in the autoexec.bat file (for Windows 95 and 98) or as environment variables (for Windows NT).
TABLE 4
Installation procedure variables
Variable Description
TI-DIR
The folder where the integrated development tool is
installed
The default is c:\ti
A-DIR
A list of folders used to find files when compiling C source
files
C-DIR
A list of folders used to find files when assembling source
files
C6X_LIBS
A list of folders that contain library files used when
compiling source files for a C6000.
C6X_INCS
A list of folders that contain include files used when
compiling and assembling source files for a C6000.
PATH
Adds TI_DIR\bin and TI_DIR\c6OOO\
ctools\bin to the PATH definition.
TPIDLL6X
Points to a DLL file needed by the IDE.
For Windows 95, the DOS shell's environment space may need to be increased to support the environment variables required to build the integrated development tool applications, and to use the gmake makefiles provided with the examples. This may be accomplished by right-clicking the shortcut used to open MS-DOS Prompt windows. Choose Properties from the pop-up menu. Go to the Memory tab and set the Initial Environment to 1024 or greater. Or, add the following line to the config.sys file and then restart the computer:
shell=c:\windows\command.com /e:4096 /p
A process of creating a simple test program that displays a “hello world” message will now be described. The example will be expanded by showing how to use DSP/BIOS to optimize this program. The main purpose of this example is to introduce the integrated development tool and to show the process used to create, build, and test programs, The source code is already stored online.
Troubleshooting Hint: If an error occurs when the IDE is started that says it can't initialize the target DSP, choose the Debug—>Reset DSP menu item. If this does not correct the problem, run a reset utility provided with a target board.
Begin by creating a project with the IDE and adding source code files and libraries to that project. In this example, standard C library functions will be used to display a “hello world” message.
1) Create a folder to contain, files to be modified. Copy all the files from the c:\ti\c6000\tutorial\heliol folder (or the corresponding subfolder for the location where the integrated development tool has been installed) to this new folder.
2) From the Windows Start menu. choose Programs—>DSP—>IDE.
3) Choose the Project—>New menu item.
4) In the Save New Project As window, select the working folder created. Type “myhello” as the project name and click Save.
5) Choose the Project-Add Files to Project menu item. Select the hello.c file and click Open.
6) Choose the Project-Add Files to Project menu item three more times to add the following files:
vectors.asm: This file contains assembly instructions needed to set the RESET interrupt service fetch packets (ISFPs) to branch to the program's C entry point, c-intOO. (For more complex programs, additional interrupt vectors can be defined in vectors.asm, or DSP/BIOS may be used to define all the interrupt vectors automatically.)
hello.cmd: Select “Linker Command File (*.cmd)” in the “Files of type” box to see this file listed. This file maps sections to memory.
rts6201.lib: Select “Library Files (*.Iib)” in the “Files of type” box. Move to the compiler library folder (C:\ti\c6000\ctools\lib) to see this file listed. This library provides run-time support for the target IDSP, When building the program, the IDE will find this file because it searches for project files in the following path order.
i) The folder that contains the source file.
ii) The folders listed in the Include Search Path for the compiler or assembler options (from left to right).
iii) The folders listed in the definitions the C-DIR (compiler) and A.DIR (assembler) environment variables (from left to right). The C-DIR environment variable defined by the installation points to the folder that contains the rts6201.lib file.
7) Expand the Project list by clicking the “+” signs next to Project, IIELLONAK, Libraries, and Source. This list is called the Project View.
To Review the code, double-click on the hello.c file in the Project View. You will see the source code in the right half of the window. You may want to make the window larger so that you clan see more of the source code at once. The source code is illustrated in Table 5
When FILE I/O is undefined, this is a simple program that uses the standard puts( ) function to display a “hello world!” message. When FILE I/O is defined, this program prompts for a string and prints it to a file. It then reads the string from the file and prints it and a message about its length to standard output.
TABLE 5
Source code for hello.c
/* ======== hello.c
#include <stdio.h>
#define BUFSIZE 30
struct PARMS
int Beta;
int EchoPower;
int ErrorPower;
int Ratio;
struct PARMS *Link:
/* ======== main
void main()
{
int
i;
char
scanStr[BUFSIZE];
char
fileStr[BUFSIZE];
size_t
readSize:
FILE
*fptr;
struct PARMS str{
2934,
9432,
213,
9432,
&str
};
puts(Hhello world!\n”);
#ifdef FILE I/O
/* clear char arrays */
for (i = 0; i < BUFSIZE; i++) {
scanStr[i3 = 0;
fileStr(i] = 0;
}
/* read a string from stdio */
scanf(11%s″, scanStr);
/* open a file on the host and write char
array */
fptr = fopen(“file.txt”, “w”);
fprintf(fptr, “As”, scanStr);
fclose(fptr);
open a file on the host and read char array */
fptr = fopen(“file.txt”, “r”);
fseek(fptr, OL, SEEK-SET);
readSize = fread(fileStr, sizeof(char), BUFSIZE, fptr);
printf(“Read a %d byte char array; %s\n”, readSize, fileStr);
fclose(fptr);
#endif
}
The code in vectors.asm and hello.cmd may be examined by double-clicking on those files.
The IDE automatically saves changes to the project setup as you make them. If you exited from the IDE, you can return to the point where you stopped working by restarting the IDE and using the Project->Open menu item. To build and run the program. perform the following steps:
1) Choose the Project-->Rebuild All menu item or click the (Rebuild All) toolbar button. The IDE will recompile, reassemble, and relink all the files in the project. Messages about this process are shown at the bottom of the window.
2) Choose the File->Load Program menu item. Select the program you just rebuilt. myhello.out, and click Open. The IDE will load the program onto the target DSP and open a dis-assembly window that shows the disassembled instructions that make up the program.
Notice that the IDE automatically opens a tabbed area at the bottom of the window to show output the program will send to stdout. Choose the Debug-->Run Program menu item or click the (Run) toolbar button. You will see the “hello world!” message in the stdout tab. Click (Halt) or press Shift F5 to stop the program.
In the previous section, the portion of the program enclosed by the preprocessor commands (#ifdef and #endif) did not run because FILE 10 was undefined. In this section, you'll learn to change program options by setting preprocessor and compilation options with the IDE.
1. Choose the Project->Options menu item.
2. In the Compiler tab, type FILE 10 in the Define Symbols box. Notice that when you tab out of this field, the compiler command line at the top of the window changes to include the -d option. The code after the #ifdef FILE 10 statement in the program will now be included when you recompile the program.
3. Click OK to save your new option settings.
4. Choose the Project->Rebuild All menu item or click the (Rebuild All) toolbar button. The IDE needs to rebuild all the files because the project options have changed.
Using Breakpoints and the Watch Window will now be described.
1. Choose the File-->Reload Program menu item.
2. Double-click on the hello.c file in the Project View. You may want to make the window larger so that you can see more of the source code at once.
3. Put your cursor in the line that says: fprintf(fptr. 11%sll, scanStr);
4. Click the (Toggle Breakpoint) toolbar button or press F9. The line will be highlighted in magenta. (You can change this color using the Option-->Color menu item.)
5. Choose the View->Watch Window menu item. You will see a separate area in the lower-right corner of the the IDE window. This area will show the values of watched variables at run-time.
6. Right-click on the Watch Window area and choose Insert New Expression from the pop-up list.
7. Type *scanStr as the Expression and click OK
8. Choose Insert New Expression from the pop-up list again. This time, type *fileStr as the Expression and click OK Both of the expressions you typed will be listed in the Watch Window. Currently, the expressions are undefined because the program is not running the main( ) function within which these variables are declared locally.
9. Choose the Debug->Run Program menu item or press F5.
10. You will be prompted to enter input for the call to scanf( ). Type any text and click OK Notice that the stdout tab shows the input text in blue. Also notice that the Watch Window now shows the value of *scanStr.
11. After you provide the input string, the program will run to the line where you set a breakpoint and stop. The next line to be executed will be highlighted in yellow.
12. Click the (Step Over) toolbar button or press F1 0 to step over the call to fprintf( ). You can use these step commands:
Step Into (F8): Steps through a single C or assembly instruction. If the instruction calls a function, steps into the function.
Step Over (F10): Steps through a single instruction. If the instruction calls a function, executes the function to completion unless a breakpoint is encountered. Stops after the function call.
Step Out (Shift F7): Completes execution of a function and stops after the current function returns to the calling function.
Run to Cursor (Ctrl F1 0): Runs up to the current cursor position in the source file or disassembly window.
Run (F5): Runs until a breakpoint is encountered.
13. Experiment with these step commands. Click (Run) or press F5 to finish running the program when you have finished experimenting.
14. Right-click on the Watch Window and choose Hide from the pop-up menu to hide the window.
15. Click (Halt) or press Shift F5 to stop the program.
16. Choose the Debug->Breakpoints menu item. In the Breakpoints tab, click Delete All and then click OK.
The Watch Window can be used with Structures.
1. Right-click on the Watch Window area and choose Insert New Expression from the pop-up list.
2. Type str as the Expression and click OK You will see a line in the Watch Window that says “+str=( . . . I”. The “+” sign indicates that this is a structure. Recall that a structure of type PARAMS was declared and initialized in hello.c.
3. Click once on the “+” sign. The IDE will expand this line to list all the elements of the structure and their values.
4. Double-click on any element in the structure to open the Edit Variable window for that element.
5. Change the value of the variable and click OK Notice that the value changes in the Watch Window.
Code execution time can be profiled. Later herein the DSP/BIOS API is used to display the “hello world!” message. In order to compare the standard putso function to the DSP/BIOS API, let's use the profiling features of the IDE.
1. Choose the File->Reload Program menu item.
2. Choose the Profiler->Enable Clock menu item. You will see a check mark next to this item in the Profiler menu. This clock counts instruction cycles. It must be enabled for profile-points to count instruction cycles.
3. Double-click on the hello.c file in the Project View.
4. Choose the View->Mixed Source/ASM menu item. You will see assembly instructions listed in gray after the equivalent C source code line.
5. Put your cursor in the line that says: puts(“hello world!\n”);
6. Click the (Toggle Profile-point) toolbar button. The C source code line and the first assembly instruction will be highlighted in green.
7. Scroll down and put your cursor in the line that says:
8. Click the (Toggle Profile-point) toolbar button. Profile-points are handled before the profile-point line is executed. They report the number of instruction cycles since the previous profile-point or since the program started running. So, the statistics for the second profile-point will report the number of cycles from when puts( ) started executing until it finished executing.
9. Choose the Profiler->View Statistics menu item. This opens an area at the bottom of the window that will display statistics about the profile-points. You can resize this area by dragging the boundaries between it and other areas of the window.
10. Click the (Run) toolbar button or press F5 to run the program.
11. Notice the number of cycles shown for the second profile-point. It should be about 2000 cycles. This is the number of cycles required to execute the call to puts( ). The average, total, maximum, and minimum are the same for these profile-points because these instructions are executed only one time.
12) Click (Halt) or press Shift F5 to stop the program.
Note: The IDE temporarily halts the target whenever it reaches a profile-point. Therefore, the target application may not be able to meet real-time deadlines when you are using profile-points.
Testing Algorithms and Canned Data
In this example, a simple algorithm is created and tested using canned data. This example will use probe-points, graphs, animation, and GEL files with the IDE. The files used in this example are:
volume.c: This is the source code for the main program. We'll examine the source code in the next section.
volume.h: This is a header file included by volumex to define various constants and structures.
load.asm: This file contains the load routine, a simple assembly loop routine that is callable from C with one argument. It consumes (9*argumeno+18 instruction cycles. vectors.asm: This is the same file used in the previous chapter to define a “reset” entry point in the DSPs interrupt vector table.
volume.cmd: This linker command file maps sections to memory.
rts6201.lib: This library provides run-time support for the target IDSR
The source code is reviewed by Double-clicking on the volume.c file in the Project View to see the source code in the right half of the IDE window, which is illustrated in Table 6
TABLE 6
Source Code example
#include <stdio.h>
#include “volume.h”
/* Global declarations
int inp_buffer[BUFSIZE];/* processing data buffers
int out-buffer[BUFSIZE]:
int gain = MINGAIN;/* volume control variable
unsigned int processing Load = BASELOAD:/* processing load
/* Functions */ extern void load(unsigned int loadValue);
static int processing(int *input, int
*output); static void dataIO(voia);
/* ======== main void maino
int *input = &inp_˜buffer[O]; int *output = &out-buffer[O];
puts(l'volume example started\n”);
/* loop forever
while(TRUE)
/* Read using a probe-point connected to a host file. dataIO();
/* apply gain processing(input, output);
/* processing
• FUNCTION: apply signal processing transform to input signal.
• PARAMETERS: address of input and output buffers.
* RETURN VALUE: TRUE.
*/ static int processing(int *input, int *output)
int size = BUFSIZE;
while(size−−){
*output++ = *input++ * gain;
/* additional processing load load(processingLoad);
return(TRUE);
/* ======== dataIO ========
FUNCTION: read input signal and write output signal.
PARAMETERS: none.
RETURN VALUE: none.
static void dataIO()
/* do data I/O return;
Notice the following parts of this example:
1) After the main function prints a message, it enters an infinite loop. Within this loop, it calls the dataI 0 and procession functions.
2) The data I/O function in this example does not perform any actions other than to return. Rather than using C code to perform I/ 0 , you will be using a probe-point within the IDE to put data from a file on the host into the inp-buffer location.
3) The processing function multiplies each value in the input buffer by the gain and puts the resulting values into the output buffer. It also calls the assembly load routine, which consumes instruction cycles based on the processing load value passed to the routine.
Adding a “probe-point” that will read data from a file on a PC will now be described. How to see a run-time graphical view of input and output data will also be described. In a real program, you would typically read data from some peripheral device, instead. The chapters that follow will show other ways to manage input and output streams. Probe points can also be used to write data from memory to a file or to cause a window to be updated at a particular point in program execution.
1) Choose the Project-->Rebuild All menu item or click the (Rebuild All) toolbar button.
2) Choose the File-->Load Program menu item. Select the program you just rebuilt. volume.out, and click Open.
3) Double-click on the volume.c file in the Project View.
4) Put your cursor in the line that says: data I/O( );
Recall that the data I/O function simply returns without performing any other actions. In this version of the volume program, you will need to use a probe-point to connect the call to data I/O to a data file.
5) Click the *(Toggle Probe-point) toolbar button. The line will be highlighted in blue. (You can change this color using the Option-->Color menu item.)
6) Choose the File-->File I/O menu item. You will see the File I/O dialog, which lets you select input and output files.
7) In the File Input tab, click Add File.
Choose the sine 6 .dat file. Notice that you can select the format of the data in the Files of Type box. The sine 6 .dat file contains hex values for a sine waveform. Click Open to add this file to the list in the File I/O dialog. You will see a control window for the sine 6 .dat file. Later, when you run the program, you will be able to use this window to start, stop, rewind, or fast forward within the data file.
9) In the File I/O dialog, change the Address to inp-buffer and the Length to Ox64. Also. put a check mark in the Wrap Around box. The Address specifies where the data from the file is to be placed. The inp-buffer is declared in volumex as an integer array of BUFSIZE. The Length specified how many samples from the data file are to be read each time the probe-point is reached. You use Ox64 because that is the value set for the BUFSIZE constant in volume.h. The Wrap Around option causes the IDE to start reading from the beginning of the file when it reaches the end of the file. This allows the data file to be treated as a continuous stream of data even though it contains only 1000 values and 100 (Ox64 hex) values are read each time the probe-point is reached.
10) Click Add Probepoint. You will see the Probe-points tab of the Bread/ Probe/Profile Points dialog.
11) Highlight the probe-point you created in step 5 (on VOLUME.C line 60 ).
12) In the Connect To field, click the down-arrow and select the sine 6 .dat file from the list.
13) Click Replace. The probe-point will show that it is connected to the sine 6 .dat file.
14) Click OK The File I/O dialog will show that the file is now connected to a probe-point.
15) Click OK in the File I/O dialog.
Displaying Graphs
If you ran the program now, you wouldn't see much information about what the program was doing. You could set watch variables on addresses within the inp-buffer and out-buffer arrays, but you'd need to watch a lot of variables and the display would be numeric rather than visual. The IDE provides a way to graph signals being processed by your program. We'll open the graphs in this section and run the program in the next section.
1) Choose the View-->Graph-Time/Frequency menu item.
2) In the Graph Property Dialog, change the Graph Title, Start Address, Acquisition Buffer Size, Display Data Size, Autoscale, and Maximum Yvalue properties to the values shown here. You will need to scroll down or resize the dialog to see all the properties.
3) Click OK You will see a graph window for the Input Buffer.
4) Random data (the values stored on the target at these addresses) is shown in the graph initially. Right-click on the Input Buffer window and choose Clear Display from the pop-up menu.
5) Choose the View->Graph—Time/Frequency menu item again.
6) This time, change the Graph Title to “Output Buffer’ and the Start Address to “out-buffer”. All the other settings are correct.
7) Click OK to display the graph window for the Output Buffer.
Animating the Program and Graphs
The IDE can display a wide variety of graph types. In this example, you'll learn to view a signal plotted against time.
1) In the Volume.c window, put your cursor in the line that calls the dataI/ 0 function.
2) Click the (Toggle Breakpoint) toolbar button or press F9. The line will be highlighted in both magenta and blue to indicate that both a breakpoint and a probe-point are set on this line.
3) Arrange the windows so that you can see both graphs.
4) Click the (Animate) toolbar button or press F12.
The IDE will run the program. Each time the program reaches the breakpoint, it will update the probe-point by getting 100 (Ox64) values from the sine 6 .dat file and writing them to the inp-buffer address. The graph windows are automatically updated when the program reaches a breakpoint. Then, the program automatically runs to the next breakpoint.
The graph windows show the input signal and the output signal. At this point, the signals are identical. Notice that each buffer contains 2.5 sine waves and the signs are reversed in these graphs. This is because the input buffer contains the values just read from sine 6 .dat. while the output buffer contains the last set of values processed by the processing function. Note: The IDE temporarily halts the target whenever it reaches probe-point. Therefore, the target application may not be able to meet real-time deadlines when you are using probe-points.
Adjusting the Gain
1) Recall that the processing function performs the following statement within a while loop: *output++=*input++* gain; This statement multiplies a value in inp-buffer by the gain and places it in the corresponding location in the out-buffer. The gain is initially set to MINGAIN, which is defined as 1 in volume.h. To modify the output, we need to change gain. One way to do this is to use a watch variable.
2) Choose the View-Match Window menu item.
3) Right-click on the Watch Window area and choose Insert New Expression from the pop-up list.
4) Type gain as the Expression and click OK. You will see the value of this variable in the Watch Window area.
5) Double-click on “gain” in the Watch Window area.
6) In the Edit Variable window, change the gain to 10 and click OK
7) If you have halted the program, click the (Animate) toolbar button.
8) Notice that the amplitude of the signal in the Output Buffer graph changes to reflect the increased gain.
Using a GEL File
The IDE provides another way of modifying a variable. This method uses GEL, a powerful extension language, to create small windows that allow you to modify variables.
1) Choose the File->Load GEL menu item. In the Open dialog, select the volume.gel file and click Open.
2) Choose the Tbols->GEL Functions->Application Control->Gain menu item. This item was added to your menus when you loaded the GEL file.
3) If you have halted the program, click the (Animate) toolbar button.
4) In the Gain window, use the slider to change the gain. You will see the amplitude change in the Output Buffer window. In addition, the value of the gain variable in the Watch Window area changes whenever you move the slider.
To see how the Gain GEL function works, click the ‘Y’ sign next to GEL Files in the Project View. Then, double-click on the VOLUME.GEL file to see its contents, is listed in Table 7
TABLE 7
Volume.GEL file
menuitem “Application Control”
dialog Load(loadParm “Load”)
{
processingLoad = loadParm;
}
ider Gain(O, 10 I, 1, gainParm)
{
gain = gainParm;
}
The Gain function defines a slider with a minimum value of 0, a maximum value of 10, and an increment and page up/down value of 1. When you move the slider, the gain variable is changed to the new value of the slider (gainParm). In the next section, we'll show how the Load GEL function works and learn more about profiling.
Adjusting and Profiling the Processing Load
In the previous chapter, we used profile-points to compare the number of cycles required to call puts and LOG-printf. Now, we will use profile-points to see the effect of changing the processingLoad variable, which is passed to the assembly load routine. The processingLoad is initially set to BASELOAD, which is defined as 1 in volume.h.
1) Choose the Prof iler->Enable Clock menu item. Make sure you see a check mark next to this item in the Profiler menu.
2) Double-click on the volume.c file in the Project View.
3) Choose the View-->Mixed Source/ASM menu item to view both the C source and the equivalent assembly instructions.
4) Scroll down to the processing function. Put your cursor in the assembly instruction after the line that says:
load(processingLoad);
5) Click the (Toggle Profile-point) toolbar button.
6) Put your cursor in the assembly instruction after the line that says:
return(TRUE);
7) Click the (Toggle Profile-point) toolbar button.
Choose the Profiler->View Statistics menu item. You may want to resize the Statistics area so that you can see the Maximum column. Or, you can right-click on the Statistics area and choose Allow Docking to display the statistics in a separate window.
9) If you have halted the program, click the (Animate) toolbar button.
10) Notice the maximum number of cycles shown for the second profile-point. It should be about 27 cycles. This is the number of cycles required to execute the load routine when the processingLoad is 1.
11) Choose the Tools->GEL Functions-->Application Control->Load menu item. This item was added to your menus when you loaded the GEL file.
12) Type 2 as the new load and click Execute. Notice that the maximum number of cycles for the second profile-point changes to 36. The number of cycles increases by 9 when you increment the processingLoad by 1.
13) Right-click on the Profile Statistics area and choose Clear All from the pop-up menu. This resets the statistics to zero. The average, maximum, and minimum will all be equal to the number of cycles for the current processingLoad.
14) Click (Halt) or press Shift F5 to stop the program.
Testing Real-Time Execution
This example modifies the previous example to introduce real-time behavior. Rather than having a main loop forever, in the real application the data 10 is likely to happen as a result of an external interrupt that occurs periodically. A simple way to simulate such an external interrupt is to use the timer interrupt from the on-chip timer.
Viewing Task Execution with the System Log
While we could test the program by putting a probe-point within the processing function and view graphs of input and output data (as we did in the previous chapter), we have already tested the signal processing algorithm. At this stage of development, our focus is on making sure the tasks can meet their real-time deadlines.
Changing the Load
Using the System Log, we saw that our program meets its real-time deadlines. However, the signal processing functions in a typical program must perform more complex and cycle consuming tasks than multiplying a value and copying it to another buffer. We can simulate such complex tasks by increasing the cycles consumed by the load function.
Testing Real-Time Execution
Another example will now be described that uses RTDX (Real-Time Data Exchange) to make real-time changes to the target.
Added the following to the list of included header files:
Added the following to the declarations:
/* RTDX channels */
RTDX-input-channel control-channel=10);
Void loadchange(Void);
Added the following call to the main function:
RTDX-enableInput(&control_channel);
Add the function illustrated in Table 9, which will be called by the PRID object you created in the previous section.
TABLE 8
RTDX Function
/* ======== loadchange ========
FUNCTION: Called by loadchange-PRD to update load value.
PARAMETERS: none.
RETURN VALUE: none.
Void loadchangeo static Int control = MINCONTROL;
/* Read new load control when host sends it if
(!RTDX_channelBusy(&control - channel))
RTDX-readNB(&control_channel, &control,
sizeof(control));
if((control < MINCONTROL)||(control > MAXCONTROL))
LOG_printf(&trace,“Control value out of range”);
else f
processingLoad = BASELOAD << control;
LOG_printf(&trace,“Load value = %d”,processingLoad);
This function uses RTDX API functions to change the load of the processing signal in “real-time”. Notice the following aspects of these changes:
The call to the RTDX—enablelnput function initializes a buffer to receive data. This buffer will be filled by a Visual Basic application that writes a load value to the buffer at run-time.
The call to the RTDX—readNB function reads the data in the buffer into the control variable.
The processingLoad=BASELOAD<<control; statement shifts the bits in BASELOAD ( 1 ) to the left by the number of digits specified by the load. Because MAXCONTROL is set to 31, the RTDX control will allow you to set an exponentially scaled value for the load up to the maximum value that can be stored in a 32-bit variable.
While we could test the program by putting a probe-point within the processing function and view graphs of input and output data (as we did in an earlier chapter), we have already tested the signal processing algorithm. At this stage of development, our focus is on making sure the tasks we've added can still meet their real-time deadlines.
1) Choose the File->Load Program menu item. Select the program you just rebuilt, volume.out, and click Open.
2) Choose the Tools->ActiveX plugins-->RTDX menu item.
3) Click Configure in the RTDX area of the window. In the General Settings tab of the RTDX Properties dialog, select Continuous RTDX mode. Then, click OK. Continuous mode allows ongoing data exchange across the channel. (Non-continuous mode allows you to write data from the target to a log file.)
4) Change “RTDX Disable” to “RTDX enable” in the RTDX area.
5) Using the Windows Explorer, run loadcrti.exe. You will see the Load Control window.
Break Points and Probe Points
The use of breakpoints to control the execution of a program and how to set probe points for signal analysis will now be described in more detail. Breakpoints are used to stop execution of the program. Once stopped, you can examine the state of your program, examine or modify variables, examine the call stack, and so on. Once the breakpoint is set, it can be enabled or disabled. Using the breakpoint button on the toolbar is the easiest way to set and clear breakpoints at any location in the program. The breakpoint dialog box allows you to set more complex breakpoints, such as conditional breakpoints, or hardware breakpoints.
To set a breakpoint using the toolbar:
1. Move the cursor to the line where you want to set the breakpoint. You can set a breakpoint in either a dis-assembly or C source window.
2. Click on the breakpoint button on the toolbar. Once set, the line is highlighted.
To remove a breakpoint using the toolbar: Move the cursor to the line containing the breakpoint. Click on the Breakpoint button on the toolbar.
To add a breakpoint using the breakpoint dialog box:
1. From the menu item, choose the DEBUG-BREAKPOINTS command.
2. Choose whether you want to “Break at location” (unconditionally) or if you want to “Break at location if expression is TRUE” (conditionally).
3. Enter the location at which you want to set the breakpoint.
A. For an absolute address, you can enter any valid C expression, the name of a C function, or a symbol name.
B. You can also enter a breakpoint location based on your C source file. This is convenient when you do not know where the C instruction will end up in the executable. The format for entering in a location based on the C source file is as follows: fileName line lineNumber
4. If you have selected a conditional breakpoint in step 2, then you must enter the condition in the Expression field.
5. Press the ADD button to create a new breakpoint. This will then cause a new breakpoint to be created and enabled.
6. Press the OK button to close the window.
To change an existing breakpoint:
1. From the menu, choose the DEBUG-BREAKPOINTS command.
2. Select a breakpoint in the breakpoint list. The selected breakpoint will become highlighted and the Type, Location, and Expression fields will be updated to match the selected breakpoint.
3. Edit the breakpoint Type, Location, and/or Expression fields as required.
4. Press the REPLACE button to change the currently selected breakpoint.
5. Press the OK button to close the window.
To delete an existing breakpoint:
1. From the menu, choose the DEBUG-BREAKPOINTS command.
2. Select a breakpoint in the breakpoint list.
3. Press the DELETE button to deleted the breakpoint.
4. Press the OK button to close the window.
To delete all breakpoints using the breakpoint dialog box:
1. From the menu, choose the DEBUG-BREAKPOINTS command.
2. Press the DELETE ALL button.
3. Press the OK button to close the window.
Once a breakpoint is set, it can be disabled or enabled. Disabling a breakpoint provides a quick way of suspending its operation temporarily, while retaining the location and type of the breakpoint.
To enable a breakpoint:
1. From the menu, choose the DEBUG-BREAKPOINTS command. This will open the breakpoint dialog box which lists all the breakpoints.
2. Select the breakpoint you wish to enable from the list. The breakpoint should have a cross beside it indicating that it is currently disabled.
3. Press the ENABLE button. This will change the cross to a check mark, indicating that the breakpoint is now enabled.
4. Press the OK button to close the window.
To disable a breakpoint:
1. From the menu, choose the DEBUG-BREAKPOINTS command. This will open the breakpoint dialog box which lists all the breakpoints.
2. Select the breakpoint you wish to disable from the list. The breakpoint should have a check mark beside it indicating that it is currently enabled.
3. Press the ENABLE button. This will change the check mark to a cross, indicating that the breakpoint is now enabled.
4. Press the OK button to close the window.
To enable all breakpoints:
1. From the menu, choose the DEBUG-BREAKPOINTS command. This will open the breakpoint dialog box which lists all the breakpoints.
2. Press the ENABLE ALL button. This button allows you to quickly enable all breakpoints in the breakpoint list.
3. Press the OK button to close the window.
To disable all breakpoints:
1. From the menu, choose the DEBUG-BREAKPOINTS command. This will open the breakpoint dialog box which lists all the breakpoints.
2. Press the DISABLE ALL button. This button allows you to quickly disable all breakpoints in the breakpoint list.
3. Press the OK button to close the window.
Conditional Breakpoints
Every conditional breakpoint has its own conditional expression. When the location of the conditional breakpoint is reached, the expression is evaluated. If the result of the expression is false, the processor will resume execution without updating the display; otherwise, the display will be updated as if a traditional breakpoint was hit.
User-defined GEL (GO DSP Extension Language) files can also be “connected” to provide necessary conditions that need to be satisfied in order for the particular breakpoint to be enabled. The user-defined GEL file can be placed in the “Expression” dialog box inside the Breakpoint manager window. This will ensure that the breakpoint will only be enabled provided a user-defined condition (as defined by a GEL file) is met. Warning: the target processor is halted while the expression is evaluated by the host. Therefore, the target application may not be able to meet real-time constraints with conditional breakpoints set.
Hardware Breakpoints
Hardware breakpoints differ from software breakpoints in that they do not modify the target program. Hardware breakpoints are useful for setting breakpoints in ROM memory or breaking on memory accesses instead of instruction acquisitions. The on-chip analysis capabilities of the TMS320C5x and TMS320C4x processors have support for one H/W breakpoint per address bus (i.e. program/data or DMA). A breakpoint can be set for a particular memory read, memory write, or memory read or write. Memory access breakpoints are not shown in the source or memory window displays.
Hardware breakpoints can also have a Count which determines the number of times a location is encountered before a breakpoint is generated. If the Count is one, a breakpoint is generated every time.
To Add a Hardware Breakpoint:
1. From the menu, choose the DEBUG-BREAKPOINTS command.
2. For the Breakpoint Type, choose “H/W Break at location” for an instruction acquisition breakpoints, or choose “break on <bus><Read/Write/R/w> at location” for a memory access breakpoint.
3. Enter the program location at which you want to set the breakpoint, or the memory location whose access you wish to break on.
A. For an absolute address, you can enter any valid C expression, the name of a C function, or a symbol name.
B. You can also enter a breakpoint location based on your C source file. This is convenient when you do not know where the C instruction will end up in the executable. The format for entering in a location based on the C source file is as follows:fileName at line lineNumber
4. Enter the number of times the location is hit before a breakpoint is generated, in the Count field. Set the count to I if you wish to break every time.
5. Press the ADD button to create a new breakpoint. This will then cause a new breakpoint to be created and enabled.
6. Press the OK button to close the window.
Probe Points
Probe Points allow the update of a particular window or the reading/writing of samples from a file to occur at a specific point in your algorithm. This effectively “connects a signal probe” to that point in your algorithm. Once the probe point is set, it can be enabled or disabled just like breakpoints. When a window object is created, it assumes that it is to be updated at every breakpoint. However, this attribute can be changed and the window can be updated only when the program reaches the connected probe point. Once the window is updated, execution of the program is continued.
With the combination of the IDE's File 1 / 0 capabilities, probe points can also be used to connect streams of data to a particular point in the DSP code. When the probe point is reached in the algorithm, data is streamed from a specific memory area to file, or from the file to memory. See FILE 1 / 0 for more details. The target processor is temporarily halted by the host processor when a probe point is encountered. Therefore, the target application may not be able to meet real-time constraints when using probe points.
To Add a Probe Point: Probe points can be created by simply placing the cursor on the line, in a source file or dis-assembly window, where you want the probe point to be, and clicking the Probe Point short-cut key on the tool bar. To be useful, probe points must be connected to a window or file (see Connecting Probe Points for more details). The DEBUG-PROBE POINTS menu command allows you to set more complex probe points, such as conditional probe points, or hardware probe points.
To delete an existing probe point:
1. From the menu, choose the DEBUG-PROBE POINTS command.
2. Select a probe point in the probe point list.
3. Press the DELETE button to delete the probe point.
4. Press the OK button to close the window.
To delete all probe points using the probe point dialog box:
1. From the menu, choose the DEBUG-PROBE POINTS command.
2. Press the DELETE ALL button.
3. Press the OK button to close the window.
To delete all probe points using the toolbar: From the toolbar, select the Delete All Probe “Points” button.
Connecting Probe Points
To connect a display window to a probe point:
1. Ensure that you have created the window which you want connected. Create the Probe Point. This can be done by first placing the cursor on the line where you want the probe point set and then clicking on the Probe Point shortcut key on the tool bar.
2. Select the command DEBUG-PROBE POINTS in the menu bar. In the list of Probe Points, you should see the new probe point that you have created. This probe point should indicate it currently has “No Connection”.
✓ echocan.c line 191 -->No Connection
3. Select this probe point to make it current. You can now edit its fields in the Probe Points dialog box.
4. Select the type of probe point: you want it to be. The default is unconditional. That is, every time the execution of the code reaches the probe point, its connected file or window is updated; execution of the code is then continued after the update. You can change the probe point to a conditional probe point, to activate the probe only if the expression is evaluated to be true.
5. Enter the location at which you want to set the probe point. If you had executed Step 2, then this field will have already been filled with the appropriate value.
A. For an absolute address, you can enter any valid C expression, the name of a C function, or the name of an assembly language label.
B. You can also enter a probe point location based on your C source file. This is convenient when you do not know where the C instruction will end up.in the executable. The format for entering in a location based on the C source file is as follows: fileName at line lineNumber
6. If you had selected a conditional probe point in step 4, then you must enter the condition in the Expression field.
7. You must now connect the window or file to the probe point. The Connect To drop down list contains all the files and windows that can be connected to the probe point. From this list select the appropriate item.
8. Once all values have been filled press the ADD button to create a new probe point or you can simply press the REPLACE button to modify the existing probe point.
Enabling and Disabling Probe Points
Once a probe point is set, it can be disabled or enabled. Disabling a probe point provides a quick way of suspending its operation temporarily, while retaining the location and type of the probe point. Warning: Windows connected to probe points that are disabled will never be updated
To enable a probe point:
1. From the menu, choose the DEBUG-PROBE POINTS command. This will open the probe point dialog box which lists all the probe points.
2. Select the probe point you wish to enable from the list. The probe point should have a cross beside it indicating that it is currently disabled.
3. Press the ENABLE button. This will change the cross to a check mark, indicating that the probe point is now enabled.
4. Press the OK button to close the window.
Shortcut: You can toggle a probe point between enabled and disabled by simply double clicking on any probe point in the list with the left mouse button.
To disable a probe point:
1. From the menu, choose the DEBUG-PROBE POINTS command. This will open the probe point dialog box which lists all the probe points.
2. Select the probe point you wish to disable from the list. The probe point should have a check mark beside it indicating that it is currently enabled.
3. Press the ENABLE button. This will change the check mark to a cross, indicating that the probe point is now enabled.
4. Press the OK button to close the window.
Shortcut: You can toggle a probe point between enabled and disabled by simply double clicking on the probe point in the list with the left mouse button.
To enable all probe points:
1. From the menu, choose the DEBUG-PROBE POINTS command. This will open the probe point dialog box which lists all the probe points.
2. Press the ENABLE ALL button. This button allows you to quickly enable all probe points in the probe point list.
3. Press the OK button to close the window.
To disable all probe points:
1. From the menu, choose the DEBUG-PROBE POINTS command. This will open the probe point dialog box which lists all the probe points.
2. Press the DISABLE ALL button. This button allows you to quickly disable all probe points in the probe point list.
3. Press the OK button to close the window.
Conditional Probe Points
Every conditional probe point has its own conditional expression. When the location of the conditional probe point is reached, the expression is evaluated. If the result of the expression is false, the processor will resume execution as if no probe point was encountered; otherwise, it will act as if a traditional probe point was hit.
Necessary conditions that need to be satisfied in order for the particular probe point to be enabled. The user-defined GEL file can be placed in the “Expression”dialog box inside the Probe Point manager window. This will ensure that the probe point will only be enabled provided a user-defined condition (as defined by a GEL file) is met.
Hardware Probe Points
Hardware probe points operate the same way as regular probe points, except they are implemented using hardware breakpoints instead of software breakpoints (See Hardware Breakpoints). Hardware probe points are useful for setting probes in ROM memory or tracing memory accesses. The target processor is temporarily halted by the host processor when a hardware probe point is encountered. Therefore, the target application may not be able to meet real-time constraints when using hardware probe points.
To Trace Memory Accesses:
1. From the menu, choose FILE-FILE 1 / 0 to create a file object that stores the data at the memory location you wish to trace (See File Input/Output).
2. Choose ADD PROBEPOINT command from the File 1 / 0 dialog box.
3. For the Probe Type, choose “probe on <bus><Read/Write/R/w> at location”.
4. Enter the memory location you want to trace.
5. Select the file object created in Step 1 from the Connect To drop down list
6. Press the ADD button to create a new probe point. This will then cause a new probe point to be created and enabled.
7. Press the OK button to close the window
Using the File Input/Output Capabilities
The IDE allows you to stream data onto (or from) the actual/simulated DSP target from a PC file. This is a great way to simulate your code using known sample values. The File Input/Output feature uses the Probe Point concept. A probe point allows the user to extract/inject samples, or take a snapshot of memory locations at a user-defined point (i.e. probe point). A probe point can be set at any point in your algorithm (similar to the way a breakpoint is set). When the execution of the program reaches a probe point, the connected object (whether it is a file, graph or memory window) is updated. Once the connected object is updated, execution continues. Using this concept, if we set a probe point at a specific point in the code, and then connect a file to this probe point, we can implement File 1 / 0 functionalities.
A file can be associated with either an input signal or an output signal. At a specific probe point, a stream of data can be either read from or written to a specified file.
To Stream data to/from a File:
1. Set a Probe Point: Before we specify information on the file, it is best to set the probe point and leave it unconnected. The probe point tells the IDE when you want to start streaming data from/to the file. That is, once the execution of the code reaches this point, the IDE will update (or read from) the file that is connected to the probe point. Once it is finished, it will start executing again. To set a probe point, simply set your cursor at the point where you want to set the probe point. Press the Toggle Probe Point button on the tool bar.
2. Select the FILE-FILE 1 / 0 command in the Pull Down Menu. Once entered, you will be prompted for specific information on FILE 1 / 0 . * The first folder in the dialog box contains information regarding File Input and the second folder is for File Output.
3. Now let's choose a specific file by pressing the ADD FILE button in either the FILE INPUT folder or the FILE OUTPUT folder. Once you have selected a file it will appear in the appropriate box. Note that more than one file can be chosen for either file input or file output. The data file can be either a COFF object file or a GO DSP data file (See Data File Formats).
4. The fields below the file list box correspond to specific information on each file. They are associated with the current file that is selected. Therefore, select a file by clicking on its name. We need to connect the file to a particular probe point. When the file is first created, it is not connected to any probe point. This is indicated by the “Not Connected” message in the probe point box. To connect the file to a probe point click on the Probe Point button on the bottom and follow the instruction in the Probe Point section. Once the file has been connected to a probe point successfully, the Probe Point Box will read “Connected”.
5. For each file selected enter valid start address, length and type values. The address field corresponds to where you want the data to be transferred to (file input) or transferred from (file output). You can enter a valid label or a numeric address in this field. The length field indicates how many samples are to be transferred to the target board (file input) or from the target board (file output) every time the selected probe point is reached. Data can be transferred to either DATA or PROGRAM by selecting the appropriate type. You can enter any valid C expression for the start address and length fields. These expressions are re-calculated EVERY time samples are to be read (or written) from (to) the target. Therefore, if you enter a symbol in this field which later changes values, you do not have to re-enter this parameter.
6. Once you press the OK button the IDE will verify the parameters you have entered and then perform file 1 / 0 when the associated probe points are reached.
Wrap Around Mode
For an Input File you have the option to select “Wrap Around” mode. This mode can be used to loop a file such that when the end of the file is reached, access then starts from the top. This feature is useful when you would like to generate a periodic signal from a file (e.g. sin). If the “Wrap Around” mode is not selected and the end of file is reached, you will be prompted with a message indicating the end of file condition and the DSP program will be halted.
File I/ 0 Controls
The File I/ 0 Control windows allow you to monitor and control the progress of the File 1 / 0 transaction. The Play button can be used to resume file 1 / 0 transactions after it has been paused by the stop button. The Stop button will halt all transfer of data from/to the file regardless of whether a probe point was hit or not. This button can be used to temporarily halt the file I/ 0 transfers. The Rewind to Beginning button will reset the file. For File Input, the next samples will be read from the top of the file. For File Output, all existing samples are deleted and the new samples are written to the top of the file. The Fast Forward button can be used to simulate an artificial Probe Point Hit. When this button is pressed, the file 1 / 0 will perform the same transaction it performs when the target hits a probe point.
In addition to these control buttons, the File I/ 0 Control windows also show the progress of the file transactions. For File Input, a progress bar indicates the percentage of samples that have been read from the file and then written to the target. For File Output, the number indicates the number of samples that have currently been written to the file.
The Graph Window
The IDE incorporates an advanced signal analysis interface designed to enable developers to monitor signal data more critically and thoroughly. The new features are useful in developing applications for communications, wireless, image processing, as well as general DSP applications. Use of the graphing capabilities of the IDE to view signals on an actual/simulated target DSP system will now be described in more detail.
All graphical display windows within the IDE environment are dockable by default. The user is, therefore, able to align the graphical display window to any section of the IDE environment screen. Disabling the “Allow Docking” property for the graph window allows for the window to he “taken out” of the general the IDE parent window to anywhere on the desktop.
Time/Frequency
The VIEW-GRAPH-TIME/FREQUENCY command can be used for graphical displays of data. Signals can be viewed in either the time or frequency domain and the graph update can be triggered at any point in your program (see Connecting a Display Window to a Probe Point for more details).
When reviewing the options, keep in mind that there are actually two buffers associated with the graph window: the “Acquisition Buffer” and the “Display Buffer”. The “Acquisition Buffer” resides on the actual/simulated target board. It contains the data that you are interested in. When a Graph is to be updated, the Acquisition Buffer is read from the actual/simulated target board and is used to update the Display Buffer. The Display Buffer resides in the host memory so it is possible to keep a history of the data. It is the Display Buffer data that is eventually graphed. For a detailed description on how the graph routine operates, please refer to Details on the GRAPH Operations. Table 9 typifies the options available for the VIEW-GRAPH-TIME/FREQUENCY command, and how they are displayed.
TABLE 9
Time/Frequency Graph options
Display Type
Graph Title
Start Address
Data Page (C2xx/C5x/C54x)
Acquisition Buffer Size
Index Increment
Display Data Size
DSP Data Type
Q-Value
Sampling Rate
Plot Data From
Left-Shifted Data Display
Autoscale
DC-Value
Maximum Y Value
Axes Display
Display Unit
Status Bar Display
Display Scale
Data Plot Style
Grid Style
Cursor Mode
Once the graph is displayed, any of the above parameters can be changed by right mouse clicking on the particular graph window, selecting Properties” and adjusting the appropriate parameters. Changing the options will force the graph to read samples (Acquisition Buffer) from the actual/simulated target board and update the graph. All the input fields are C expression input fields.
Five display types can be selected to allow for viewing data in a number of different ways. The five display type options associated with a particular graph, along with the appropriate explanations of what each display type corresponds to are as follows:
1) Single Time
The data in the Display Buffer will be plotted on a magnitude versus time graph with no preprocessing. A single time trace of a signal is displayed on the graph.
2) Dual Time
The data in the Display Buffer will be plotted on a magnitude versus time graph with no preprocessing. A dual time trace of signal(s) is displayed on the graph, allowing the user to plot two time domain traces into a single graph window. When this option is set, an additional property item appears in the Graph Properties window—Interleaved Data Sources, allowing you to provide further specifications on whether the data sources are interleaved into I acquisition buffer or if they come from 2 separate buffets.
3) FFT Magnitude
A Fast Fourier Transform (FFT) is performed on the data in the Display Buffer and a magnitude versus frequency graph is plotted. The FFT routine uses the FFT Framesize (rounded up to the nearest power of 2) to determine the minimum number of samples. When the FFT Magnitude display data type is selected, two additional property items appear in the Graph Properties window—Interleaved Data Sources and Signal Type, allowing the user to provide further specification on the nature of the signal sources. Three additional property items are also displayed when viewing an FFT Magnitude graph, as indicated below: In addition, when the FFT Magnitude graphical display option is selected, a property field option Display Peak and Hold is displayed, allowing for further specification on how the history of the samples is graphically maintained.
a) FFT Framesize—specifies the number of samples used in each FFT calculation (PLEASE NOTE: The acquisition buffer can be a different size than the FFT Framesize)
b) FFT Order—specifies the FFT Size=2 FFT Order,
c) FFT Windowing Function -scrollable list including 4 windowing functions Rectangle, Bartlett, Blackman, Harming, Hamming), performed on the data before the FFT calculation is performed
4) Complex FITT
An FFT consisting of a real and imaginary data portion will be displayed on 2 graphs that are contained in the same graphical display window. When the Complex FFT display data type is selected, two additional property items appear in the Graph Properties window—Interleaved Data Sources and Number of Signal Sources, allowing the user to provide further specification on the nature of the signal sources. Three additional property items are also displayed when viewing a Complex FFT graph, as indicated below:
a) FFT Framesize—specifies the number of samples used in each FFT calculation (PLEASE NOTE: The acquisition buffer can be a different size than the FFT Framesize)
b) FFT Order—specifies the FFT Size=2 FFT Order
c) FFT Windowing Function—scrollable list including 4 windowing functions (Rectangle, Bartlett, Blackman, Harming, Hamming), performed on the data before the FFT calculation is performed
5) FFT Magnitude and Phase
An FFT consisting of a magnitude and phase portion will be displayed in the same graphical display window. When the FFT Magnitude and Phase display data type is selected, two additional property items appear in the Graph Properties window—Interleaved Data Sources and Number of Signal Sources, allowing the user to provide further specification on the nature of the signal sources. Three additional property items are also displayed when viewing an FFT Magnitude and Phase graph, as indicated below:
a) FFT Framesize—specifies the number of samples used in each FFT calculation (PLEASE NOTE: The acquisition buffer can be a different size than the FFT Framesize)
b) FFT Order—specifies the FFT Size=2 FFT Order
c) FFT Windowing Function—scrollable list including 4 windowing functions (Rectangle. Bartlett, Blackman, Hanning, Hamming), performed on the data before the FFT calculation is performed
In addition, when the FFT Magnitude and Phase graphical display option is selected, a property field option Display Peak and Hold is displayed, allowing for further specification on how the history of the samples is graphically maintained.
6) FFT Waterfall
An FFT is performed on the data in the Display Buffer and a magnitude versus frequency graph is plotted as a frame. A chronological series of these frames forms an FFT waterfall graph. When the FFT Waterfall display data type is selected, two additional property items appear in the Graph Properties window—Interleaved Data Sources and Signal Type, allowing the user to provide further specification on the nature of the signal sources. Five additional property items are also displayed when viewing an FFT Waterfall graph, as indicated below:
a) FFT Framesize—specifies the number of samples used in each FFT calculation (PLEASE NOTE: The acquisition buffer can be a different size than the FFT Framesize)
b) FFT Order—specifies the FFT Size=2 FFT Od,; there will be zero padding if FFT Framesize is smaller than FFT Order
c) FFT Windowing Function—scrollable list including 5 windowing functions (Rectangle, Bartlett. Blackman, Hanning, Hamming), performed on the data before the FFT calculation is performed
d) Number of Waterfall Frames—specifies the number of waterfall frames to be displayed
e) Waterfall Height (%)—specifies the percentage of vertical window height that is used to display a waterfall frame
Graph Title—Each graph that you create can be identified by an appropriate title. This helps to distinguish results when there are many windows open.
Signal Type—This graph display option allows the user to specify the TYPE of signal source that is to be used to produce a particular graph. Two options are available for the Signal Type property—real (corresponding to a single source display in the case of a single time display, for instance) and complex (corresponding to two signal sources). When COMPLEX is selected, the Interleaved Data Source option is displayed allowing for specification of whether the signal sources are interleaved.
Start Address—This is the starting location (on the actual/simulated target board) of the Acquisition Buffer containing the data to be graphed. When the Graph is to be updated, the Acquisition Buffer starting at this location is fetched from the actual/simulated target board. This Acquisition Buffer is then used to update the Display Buffer. It is the display buffer that is graphed. You can enter any valid C expression for the start address field. This expression is recalculated EVERY time samples are to be read from the actual/simulated target. Therefore, if you enter a symbol in this field, which later changes values, you do not have to re-enter this parameter.
Acquisition Buffer Size—This is the size of the Acquisition Buffer you are using on your actual/simulated target board. For example, if you are processing samples one-at-a-time in a serial fashion, enter ‘I’ in this field. For this example, ensure that you have enabled the Left Shifted Data Display option and have connected the display to the correct location in your DSP program (see Connecting a Display Window to a Probe Point for more details). If your program processes an entire frame at a time (i.e. more than one sample) and you are only interested in that particular frame, it is recommended that you enter the same value for the Acquisition Buffer Size and the Display Size. You should also turn off the Left Shifted Data Display option. When a graph is to be updated, the Acquisition Buffer is read from the actual/simulated target board and is used to update the Display Buffer. It is the Display Buffer that is graphed. You can enter any valid C expression for the acquisition buffer size field. This expression is re-calculated EVERY time samples are to be read from the actual/simulated target. Therefore, if you enter a symbol in this field, which later changes values, you do not have to re-enter this parameter.
Index Increment—This field allows the user to specify the sample index increment for the graphical display of data. A specification in this field is equivalent to a sample OFFSET for non-interleaved sources. This permits the user to extract signal data from multiple sources using a single graphical display—an index increment of 2, for instance, corresponds to a sample offset value of 2, which in turn graphically displays every other sample in the acquisition buffer. The user can therefore specify multiple data sources for display by entering a corresponding offset value in this field. This option provides a general specification for interleaved sources. If the Interleaved Data Sources option is selected, the index increment option is disabled.
Display Data Size—This is the size of the Display Buffer that you want to use. It is the Display Buffer that is graphed on your screen. The Display Buffer resides on the host, so that a history of your signal can be displayed even though it no longer exists on the actual/simulated target board. The size of the display is determined differently depending on what you have selected for the Time Domain/Frequency Domain (Display Type) option. For a time domain graph, the Display Data Size contains the number of samples that the graph will display. No preprocessing is done on the display buffer. Usually the Display Data Size is greater than or the same as the Acquisition—Buffer Size. If the Display Data Size is greater than the Acquisition Buffer Size, the Buffer data can be Left Shifted into the Display Buffer. For a frequency domain graph (FFT Magnitude, Complex FFT, FFT Magnitude and Phase), the Display Size is represented by the FFT Framesize (rounded up to the nearest power of 2) used for the FFT frequency analysis. You can enter any, valid C expression for the display data size field. This expression is re-calculated EVERY time samples are to be read from the actual/simulated target. Therefore, if you enter a symbol in this field which later changes values, you do not have to re-enter this parameter.
Interleaved Data Sources—Toggling this display option allows for a single buffer input to represent 2 sources. Setting this particular option to ““Yes” implies a 2-source input buffer where the odd samples represent the first source and even samples represent the second. Setting this option to ““Yes” creates only a single Start Address prompt in the Graphical Properties window, corresponding to the single buffer input (with dual interleaved sources). Setting this option to ““No” creates two starting address fields, corresponding to two buffer source signal inputs not interleaved.
The following are the additional display options created when the “No” option is selected for Interleaved Data Sources in conjunction with particular display types:
If Dual Time is selected:
1) Start Address—upper display
2) Start Address—lower display
If any of the following display types are selected: FFT Magnitude, Complex FFT, FFT Magnitude and Phase, the following start address options appear:
1) Start Address—real data
2) Start Address—imaginary data
The graph menu contains many options to allow the user to be flexible in the way they want to display the information. This section contains a brief description on how the graph routine works to let you master all capabilities of the Graph Window.
Once all options are entered on the graph menu screen, the graph window gets a Sample Buffer of DSP data of length Acquisition Buffer Size starting at DSP location Start Address in the data memory space. A Display Buffer of size Display Data Size is allocated within the host memory with all its values initialized to zero.
If the Left-Shifted Data Display option is chosen, the entire Display Buffer is left shifted by Acquisition Buffer Size with the values of the DSP Acquisition Buffer shifted in from the right end. If the Left-Shifted Data Display option is not chosen then the values of the Display Buffer are simply overwritten by the DSP Acquisition Buffer. The Left-Shifted Data Display option is useful when you are processing a signal in serial fashion. Although the samples are only available one at a time, the Left Shift Option lets you view a history of the samples. When the associated probe point is reached (See Probe Points for details) a block of DSP data is read and the display is updated.
If Frequency Domain analysis is chosen, the Display Buffer is run through an FFT routine to give a frequency domain analysis of the data. If the Time Domain analysis is chosen, no preprocessing is done on the display data before it is graphed.
Once the graph is displayed, any of the above parameters can be changed by right mouse clicking on the particular graph window, selecting “Properties” and adjusting the appropriate parameters. Changing options will force the graph to read samples (Acquisition Buffer) from the actual/simulated DSP target board and update the graph.
Constellation Diagram
The VIEW-GRAPH-CONSTELLATION allows the user to graphically measure how effectively the information is extracted from the input signal. The input signal is separated into two components and the resulting data is then plotted using the Cartesian coordinate system in the time fashion by plotting one signal versus the other (Y Source versus X Source where Y Source is plotted in the direction of Y axis and X Source in the direction of X-axis). Graph update can be triggered at any point in your program (see Connecting a Display Window to a Probe Point, for more details).
When reviewing the options, keep in mind that there are actually two buffers associated with the graph window for each signal: the “Acquisition Buffer” and the “Display Buffer”. The Acquisition Buffer resides on the actual/simulated target board. It contains the data that you are interested in. When a Graph is to be updated, the Acquisition Buffer is read from the actual/simulated target board and is used to update the Display Buffer. The Display Buffer resides in the host memory so it is possible to keep a history of the data. It is the Display Buffer data that is eventually graphed. For a detailed description on how the graph routine operates, please refer to Details on the GRAPH Operations. Table 10 typifies the options available for the VIEW-GRAPH-CONSTELLATION command, and how they are displayed:
TABLE 10
Constellation Graph options
Graph Title
Interleaved Data Sources
Start Address
Data Page (C2xxIC5xIC54x)
Acquisition Buffer Size
Index Increment
Constellation Points
DSP Data Type
Q-Value
Minimum X Value
Maximum X Value
Minimum Y Value
Maximum Y Value
Symbol Size
Axes Display
Status Bar Display
Grid Style
Cursor Mode
Once the graph is displayed, any of the above parameters can be changed by right mouse clicking on the particular graph window, selecting ““Properties” and adjusting the appropriate parameters. Changing the options will force the graph to read samples (Acquisition Buffer) from the actual/simulated target board and update the graph.
Constellation Points—This is the size of the Display Buffer that you want to display. It is the Display Buffer that is graphed on your screen. The Display Buffer resides on the host so that a history of your signal can be displayed even though it no longer exists on the actual/simulated target board. Constellation Points contains the maximum number of samples that the graph will display. Usually the Constellation Points is greater than or the same as the Acquisition Buffer Size. If the Constellation Points is greater than the Acquisition Buffer Size, the Acquisition Buffer data is left shifted into the Display Buffer. You can enter any valid ‘C’ expression for the constellation points field. This expression is calculated once when you click OK button in the graph property dialog.
Eye Diagram
The VIEW-GRAPH-EYE DIAGRAM command can be used for qualitatively examining signal fidelity. Incoming signals are continuously superimposed upon each other within a specified display range and displayed in an t 1 ye shape”-signal clarity becomes directly proportional to the area covered by the eye diagram. The periodicity of the signal is shown in the time fashion by plotting the signal in a serial manner and wrapping it around when a Zero-Crossing is detected. Graph update can be triggered at any point in your program (see Connecting a Display Window to a Probe Point for more details).
When reviewing the options, keep in mind that there are actually two buffers associated with the graph window: the “Acquisition Buffer” and the “Display Buffer”. The Acquisition Buffer resides on the actual/simulated target board. It contains the data that you are interested in. When a Graph is to be updated, the Acquisition Buffer is read from the actual/simulated target board and is used to update the Display Buffer. The Display Buffer resides in the host memory so it is possible to keep a history of the data. It is the Display Buffer data that is eventually graphed. For a detailed description on how the graph routine operates, please refer to Details on the GRAPH Operations. Table typifies the options available for the VIEW-GRAPH-EYE DIAGRAM command, and how they are displayed:
TABLE 11
Eye Diagram options
Graph Title
Trigger Source
Interleaved Data Sources
Start Address
Data Page (C2xxIC5xIC54x)
Acquisition Buffer Size
Index Increment
Persistence Size
Display Length
Minimum Interval Between Triggers
Pre-Trigger (in samples)
DSP Data Type
Q-Value
Sampling Rate
Trigger Level
Maximum Y Value
Axes Display
Time Display Unit
Status Bar Display
Grid Style
Cursor Mode
Once the graph is displayed, any of the above parameters can be changed by right mouse clicking on the particular graph window, selecting “Properties” and adjusting the appropriate parameters. Changing the options will force the graph to read samples (Acquisition Buffer) from the actual/simulated target board and update the graph.
Persistence Size—This is the size of the Display Buffer that you want to display. It is the Display Buffer that is graphed on your screen. The Display Buffer resides on the host, so that a history of your signal can be displayed even though it no longer exists on the actual/simulated target board. The Persistence Size contains the number of samples in history that the graph will display. Usually the Persistence Size is greater than or the same as the Acquisition Buffer Size. If the Persistence Size is greater than the Acquisition Buffer Size, the Acquisition Buffer data is left shifted into the Display Buffer. Please note that the graphing on screen is cumulative and that, as a result, the graph window may display more samples than the specified Persistence Size. Any older data can be flushed “out” from the Display Buffer with incoming samples in excess of the specified Persistence Size by right mouse clicking on the window and selecting Refresh” This will equate the Persistence Size to the Display Buffer length.
Pre-Trigger (in samples)—This option sets the number of samples to be displayed before the left trigger point. It has the effect of panning the left trigger point towards the left or right hand side of the screen. This option is useful in visualizing the signal around the trigger point. Setting this option to zero will place the left trigger point on the left boundary of the graph window. Setting this option to a positive value will move the left trigger point towards the right boundary of the window. Setting this option to a negative value will move the left trigger point to the left side of the left boundary window, which is outside the window. With the effect of wrap-around, the point is moved away from the right boundary of the window.
When the graph is to be updated, the entire Display Buffer is left shifted by Acquisition Buffer Size with the values of the DSP Acquisition Buffer shifted in from the right end. This is useful when you are processing a signal in a serial fashion. Although the samples are only available one at a time, this manner lets you view a history of the samples. When the associated probe point is reached (See Probe Points for details) a Block of DSP data is read and the Display is updated.
Once the graph is displayed, any of the above parameters can be changed by right mouse clicking on the particular graph window, selecting “Properties” and adjusting the appropriate parameters. Changing options will force the graph to read samples (Acquisition Buffer) from the actual/simulated DSP target board and update the graph. | An integrated code development tool, comprising of an editor, a project management and build system, a debugger, a profiler, and a graphical data visualization system. The editor is operable to provide a source code view which is simultaneously capable of integrating with said debugger to provide for stepping through code and setting breakpoints, and integrating with the output of said build system to display source code interleaved with corresponding assembler code created by said build system. | 112,361 |
CROSS REFERENCES TO RELATED APPLICATIONS
This application claims priority from and is related to commonly owned U.S. Provisional Patent Application Ser. No. 61/452,450 filed Mar. 14, 2011, entitled: Apparatus for Plasma Dicing a Semi-conductor Wafer, this Provisional Patent Application incorporated by reference herein. This application is a continuation-in-part of co-pending patent application Ser. No. 13/412,119 filed on Mar. 5, 2012, entitled: Method and Apparatus for Plasma Dicing a Semi-conductor Wafer, the contents of which are incorporated herein.
FIELD OF THE INVENTION
The invention relates to the use of an apparatus for the formation of individual device chips from a semi-conductor wafer, and in particular to an apparatus which uses plasma etching to separate the wafer into individual die.
BACKGROUND
Semi-conductor devices are fabricated on substrates which are in the form of thin wafers. Silicon is commonly used as the substrate material, but other materials, such as III-V compounds (for example GaAs and InP) are also used. In some instances (for example, the manufacture of LED's) the substrate is a sapphire or silicon carbide wafer on which a thin layer of a semi-conducting material is deposited. The size of such substrates ranges from 2 inches and 3 inches up to 200 mm, 300 mm, and 450 mm diameter and many standards exist (e.g., SEMI) to describe such substrate sizes.
Plasma etching equipment is used extensively in the processing of these substrates to produce semi-conductor devices. Such equipment typically includes a vacuum chamber fitted with a high density plasma source such as Inductively Coupled Plasma (ICP) which is used to ensure high etch rates, necessary for cost-effective manufacturing. In order to remove the heat generated during the processing, the substrate is typically clamped to a cooled support. A cooling gas (typically Helium) is maintained between the substrate and the support to provide a thermal conductance path for heat removal. A mechanical clamping mechanism, in which a downward force is applied to the top side of the substrate, may be used, though this may cause contamination due to the contact between the clamp and the substrate. More frequently an Electrostatic chuck (ESC) is used to provide the clamping force.
Numerous gas chemistries appropriate to the material to be etched have been developed. These frequently employ a halogen (Fluorine, Chlorine, Bromine, or Iodine) or halogen-containing gas together with additional gases added to improve the quality of the etch (for example, etch anisotropy, mask selectivity and etch uniformity). Fluorine containing gases, such as SF 6 , F 2 or NF 3 are used to etch silicon at a high rate. In particular, a process (Bosch or time division multiplexed “TDM”) which alternates a high rate silicon etch step with a passivation step to control the etch sidewall, is commonly used to etch deep features into silicon. Chlorine and Bromine containing gases are commonly used to etch III-V materials.
Plasma etching is not limited to semiconducting substrates and devices. The technique may be applied to any substrate type where a suitable gas chemistry to etch the substrate is available. Other substrate types may include carbon containing substrates (including polymeric substrates), ceramic substrates (e.g., AlTiC and sapphire), metal substrates, and glass substrates.
To ensure consistent results, low breakage and ease of operation, robotic wafer handling is typically used in the manufacturing process. Handlers are designed to support the wafers with minimal contact, to minimize possible contamination and reduce the generation of particulates. Edge contact alone, or underside contact close to the wafer edge at only a few locations (typically within 3-6 mm of the wafer edge) is generally employed. Handling schemes, which include wafer cassettes, robotic arms and within process chamber fixtures including the wafer support and ESC, are designed to handle the standard wafer sizes as noted previously.
After fabrication on the substrate, the individual devices (die or chips) are separated from each other prior to packaging or being employed in other electronic circuitry. For many years, mechanical means have been used to separate the die from each other. Such mechanical means have included breaking the wafer along scribe lines aligned with the substrate crystal axis or by using a high speed diamond saw to saw into or through the substrate in a region (streets) between the die. More recently, lasers have been used to facilitate the scribing process.
Such mechanical wafer dicing techniques have limitations which affect the cost effectiveness of this approach. Chipping and breakage along the die edges can reduce the number of good die produced, and becomes more problematic as wafer thicknesses decrease. The area consumed by the saw bade (kerf) may be greater than 100 microns which is valuable area not useable for die production. For wafers containing small die (e.g., individual semiconductor devices with a die size of 500 microns×500 microns) this can represent a loss of greater than 20%. Further, for wafers with many small die and hence numerous streets, the dicing time is increased, and productivity decreased, since each street is cut individually. Mechanical means are also limited to separation along straight lines and the production of square or oblong shaped chips. This may not represent the underlying device topology (e.g., a high power diode is round) and so the rectilinear die format results in significant loss of useable substrate area. Laser dicing also has limitations by leaving residual material on the die surface or inducing stress into the die.
It is important to note that both sawing and laser dicing techniques are essentially serial operations. Consequently, as device sizes decrease, the time to dice the wafer increases in proportion to the total dicing street length on the wafer.
Recently plasma etching techniques have been proposed as a means of separating die and overcoming some of these limitations. After device fabrication, the substrate is masked with a suitable mask material, leaving open areas between the die. The masked substrate is then processed using a reactive-gas plasma which etches the substrate material exposed between the die. The plasma etching of the substrate may proceed partially or completely through the substrate. In the case of a partial plasma etch, the die are separated by a subsequent cleaving step, leaving the individual die separated. The technique offers a number of benefits over mechanical dicing:
1) Breakage and chipping is reduced;
2) The kerf dimensions can be reduced to well below 20 microns;
3) Processing time does not increase significantly as the number of die increases;
4) Processing time is reduced for thinner wafers; and
5) Die topology is not limited to a rectilinear format.
After device fabrication, but prior to die separation, the substrate may be thinned by mechanical grinding or similar process down to a thickness of a few hundred microns, or even less than a hundred microns.
Prior to the dicing process, the substrate is typically mounted on a dicing fixture. This fixture is typically comprised of a rigid frame that supports an adhesive membrane. The substrate to be diced is adhered to the membrane. This fixture holds the separated die for subsequent downstream operations. Most tools used for wafer dicing (saws or laser based tools) are designed to handle substrates in this configuration and a number of standard fixtures have been established; however, such fixtures are very different from the substrates which they support. Though such fixtures are optimized for use in current wafer dicing equipment, they cannot be processed in equipment which has been designed to process standard substrates. Thus, current automated plasma etching equipment is not suitable for processing substrates fixtured for dicing and it is difficult to realize the benefits that plasma etch techniques should have for die separation.
Some groups have contemplated using plasma to singulate die from wafer substrates. U.S. Pat. No. 6,642,127 describes a plasma dicing technique in which the substrate wafer is first attached to a carrier wafer via an adhesive material, before plasma processing in equipment designed for processing silicon wafers. This technique proposes adapting the form factor of the substrate to be diced to be compatible with standard wafer processing equipment. While this technique allows standard plasma equipment to dice the wafer, the proposed technique will not be compatible with standard equipment downstream of the dicing operation. Additional steps would be required to either adapt the downstream equipment or revert the substrate form factor for standard downstream equipment.
U.S. Patent Application 2010/0048001 contemplates the use of a wafer adhered to a thin membrane and supported within a frame. However, in the 2010/0048001 application, the masking process is achieved by adhering a mask material to the backside of the wafer and using a laser to define the etch streets prior to plasma processing. In contrast to standard dicing techniques which singulate the substrate from the front side, this technique introduces additional complex and expensive steps which may negate some of the advantages of plasma dicing. It also requires the additional demand of aligning the backside mask with the front side device pattern.
Therefore, what is needed is a plasma etching apparatus which can be used for dicing a semiconductor substrate into individual die and which is compatible with the established wafer dicing technique of handling a substrate mounted on tape and supported in a frame, and which is also compatible with standard front side masking techniques.
Nothing in the prior art provides the benefits attendant with the present invention.
Therefore, it is an object of the present invention to provide an improvement which overcomes the inadequacies of the prior art devices and which is a significant contribution to the advancement to the dicing of semiconductor substrates using a plasma etching apparatus.
Another object of the present invention is to provide a method for plasma dicing a substrate, the method comprising: providing a process chamber having a wall; providing a plasma source adjacent to the wall of the process chamber; providing a work piece support within the process chamber; placing a work piece onto the work piece support, said work piece having a support film, a frame and the substrate; loading the work piece onto the work piece support; applying a tensional force to the support film; clamping the work piece to the work piece support; generating a plasma using the plasma source; and etching the work piece using the generated plasma.
Yet another object of the present invention is to provide a method for plasma dicing a substrate, the method comprising: providing a process chamber having a wall; providing a plasma source adjacent to the wall of the process chamber; providing a work piece support within the process chamber; placing a work piece onto the work piece support, said work piece having a support film, a frame and the substrate; loading the work piece onto the work piece support; positioning the frame non-coplanar to the substrate on the work piece support; clamping the work piece to the work piece support; generating a plasma using the plasma source; and etching the work piece using the generated plasma.
Still yet another object of the present invention is to provide a method for plasma dicing a substrate, the method comprising: providing a process chamber having a wall; providing a plasma source adjacent to the wall of the process chamber; providing a work piece support within the process chamber; placing a work piece onto the work piece support, said work piece having a support film, a frame and the substrate; loading the work piece onto the work piece support; applying a tensional force to the support film; generating a plasma using the plasma source; and etching the work piece using the generated plasma.
Another object of the present invention is to provide a method for plasma dicing a plurality of substrates, the method comprising: providing a process chamber having a wall; providing a plasma source adjacent to the wall of the process chamber; providing a work piece support within the process chamber; placing a work piece onto the work piece support, said work piece having a support film, a frame and the plurality of substrates; loading the work piece onto the work piece support; clamping the work piece to the work piece support; generating a plasma using the plasma source; and etching the work piece using the generated plasma.
The foregoing has outlined some of the pertinent objects of the present invention. These objects should be construed to be merely illustrative of some of the more prominent features and applications of the intended invention. Many other beneficial results can be attained by applying the disclosed invention in a different manner or modifying the invention within the scope of the disclosure. Accordingly, other objects and a fuller understanding of the invention may be had by referring to the summary of the invention and the detailed description of the preferred embodiment in addition to the scope of the invention defined by the claims taken in conjunction with the accompanying drawings.
SUMMARY OF THE INVENTION
The present invention describes a plasma processing apparatus which allows for plasma dicing of a semiconductor substrate. After device fabrication and wafer thinning, the front side (circuit side) of the substrate is masked using conventional masking techniques which protects the circuit components and leaves unprotected areas between the die. The substrate is mounted on a thin tape which is supported within a rigid frame. The substrate/tape/frame assembly is transferred into a vacuum processing chamber and exposed to reactive gas plasma where the unprotected areas between the die are etched away. During this process, the frame and tape are protected from damage by the reactive gas plasma. The processing leaves the die completely separated. After etching, the substrate/tape/frame assembly is additionally exposed to plasma which removes potentially damaging residues from the substrate surface. After transfer of the substrate/tape/frame assembly out of the process chamber, the die are removed from the tape using well known techniques and are then further processed (e.g., packaged) as necessary.
Another feature of the present invention is to provide a method for plasma dicing a substrate. The substrate can have a semiconducting layer such as Silicon and/or the substrate can have a III-V layer such as GaAs. The substrate can have a protective layer such as a photoresist layer that is patterned on a circuit side of the substrate. A process chamber having a wall with a plasma source adjacent to the wall of the process chamber is provided. The plasma source can be a high density plasma source. A vacuum pump in fluid communication with the process chamber and a gas inlet in fluid communication with the process chamber can be provided. A work piece support within the process chamber is provided. A work piece is formed by placing the substrate on a carrier support. The work piece can be formed by adhering the substrate to a support film and then mounting the substrate with the support film to a frame. The support film can have a polymer layer and/or a conductive layer. The support film can be standard dicing tape. The frame can have a conductive layer and/or a metal layer. The work piece is then loaded onto the work piece support for plasma processing. An RF power source can be coupled to the work piece support to create a plasma around the work piece. A tensional force is applied to the support film. The tensional force can be applied to the frame. The tensional force can be a mechanical force, a magnetic force and/or an electrical force. The support film can be elastically deformed by the tensional force. The support film cannot be plastically deformed by the tensional force. A heat transfer fluid can be introduced between the support film and the work piece. The heat transfer fluid can be a gas such as helium. The fluid pressure can be greater than one Torr and can be less than thirty Torr. An electrostatic or mechanical chuck can be incorporated into the work piece support whereby the chuck can clamp the support film to the chuck. The clamping of the work piece can be performed after the tensional force is applied to the support film. The tensional force that is applied to the support film can be changed after the support film is clamped. The tensional force that is applied to the support film can be removed after the support film is clamped. The pressure within the process chamber can be reduced through the vacuum pump and a process gas can be introduced into the process chamber through the gas inlet. A plasma is generated through the plasma source whereby the work piece is etched through the generated plasma. A vacuum compatible transfer module can be provided that communicates with the process chamber. The work piece can be loaded onto a transfer arm in the vacuum compatible transfer module whereby the process chamber is maintained under vacuum during a transfer of the work piece from the vacuum compatible transfer module to the process chamber.
Yet another object of the present invention is to provide a method for plasma dicing a substrate. The substrate can have a semiconducting layer such as Silicon and/or the substrate can have a III-V layer such as GaAs. The substrate can have a protective layer such as a photoresist layer that is patterned on a circuit side of the substrate. A process chamber having a wall with a plasma source adjacent to the wall of the process chamber is provided. The plasma source can be a high density plasma source. A vacuum pump in fluid communication with the process chamber and a gas inlet in fluid communication with the process chamber can be provided. A work piece support within the process chamber is provided. A work piece is formed by placing the substrate on a carrier support. The work piece can be formed by adhering the substrate to a support film and then mounting the substrate with the support film to a frame. The support film can have a polymer layer and/or a conductive layer. The support film can be standard dicing tape. The frame can have a conductive layer and/or a metal layer. The work piece is then loaded onto the work piece support for plasma processing. An RF power source can be coupled to the work piece support to create a plasma around the work piece. The frame is positioned non-coplanar to the substrate on the work piece support. The support film can contact a first surface of the substrate. The support film can contact a second surface of the frame. The substrate can be positioned above the frame during the positioning step. The first surface of the substrate can be positioned non-coplanar to the second surface of the frame during the positioning step. The first surface of the substrate can be positioned above the second surface of the frame. The substrate can be supported by the work piece support and the frame can be supported by the work piece support. The substrate can be supported by the clamp and the frame can be supported by a process kit. The substrate can be supported by a clamp and the frame can be supported by a lift mechanism. The support film can be supported by the work piece support and the frame can be unsupported. An inner diameter of the frame can be greater than an outer diameter of the work piece support. The support film can be supported by the work piece support and the frame can be supported by a lift mechanism. The clamp can be an electrostatic chuck or a mechanical chuck which can be incorporated into the work piece support. The pressure within the process chamber can be reduced through the vacuum pump and a process gas can be introduced into the process chamber through the gas inlet. A plasma is generated through the plasma source whereby the work piece is etched through the generated plasma. A vacuum compatible transfer module can be provided that communicates with the process chamber. The work piece can be loaded onto a transfer arm in the vacuum compatible transfer module whereby the process chamber is maintained under vacuum during a transfer of the work piece from the vacuum compatible transfer module to the process chamber.
Still yet another object of the present invention is to provide a method for plasma dicing a substrate. The substrate can have a semiconducting layer such as Silicon and/or the substrate can have a III-V layer such as GaAs. The substrate can have a protective layer such as a photoresist layer that is patterned on a circuit side of the substrate. A process chamber having a wall with a plasma source adjacent to the wall of the process chamber is provided. The plasma source can be a high density plasma source. A vacuum pump in fluid communication with the process chamber and a gas inlet in fluid communication with the process chamber can be provided. A work piece support within the process chamber is provided. A work piece is formed by placing the substrate on a carrier support. The work piece can be formed by adhering the substrate to a support film and then mounting the substrate with the support film to a frame. The support film can have a polymer layer and/or a conductive layer. The support film can be standard dicing tape. The frame can have a conductive layer and/or a metal layer. The work piece is then loaded onto the work piece support for plasma processing. An RF power source can be coupled to the work piece support to create a plasma around the work piece. A tensional force is applied to the support film. The tensional force can be applied to the frame. The tensional force can be a mechanical force, a magnetic force and/or an electrical force. The support film can be elastically deformed by the tensional force. The support film cannot be plastically deformed by the tensional force. A heat transfer fluid can be introduced between the support film and the work piece. The heat transfer fluid can be a gas such as helium. The fluid pressure can be greater than one Torr and can be less than thirty Torr. The pressure within the process chamber can be reduced through the vacuum pump and a process gas can be introduced into the process chamber through the gas inlet. A plasma is generated through the plasma source whereby the work piece is etched through the generated plasma. A vacuum compatible transfer module can be provided that communicates with the process chamber. The work piece can be loaded onto a transfer arm in the vacuum compatible transfer module whereby the process chamber is maintained under vacuum during a transfer of the work piece from the vacuum compatible transfer module to the process chamber.
Another object of the present invention is to provide a method for plasma dicing a plurality of substrates. The plurality of substrates can have a semiconducting layer such as Silicon and/or the substrates can have a III-V layer such as GaAs. The plurality of substrates can have a protective layer such as a photoresist layer that is patterned on a circuit side of the substrate. A process chamber having a wall with a plasma source adjacent to the wall of the process chamber is provided. The plasma source can be a high density plasma source. A vacuum pump in fluid communication with the process chamber and a gas inlet in fluid communication with the process chamber can be provided. A work piece support within the process chamber is provided. A work piece is formed by placing the plurality of substrates on a carrier support. The work piece can be formed by adhering the plurality of substrates to a support film and then mounting the plurality of substrates with the support film to a frame. The support film can have a polymer layer and/or a conductive layer. The support film can be standard dicing tape. The frame can have a conductive layer and/or a metal layer. The work piece is then loaded onto the work piece support for plasma processing. An RF power source can be coupled to the work piece support to create a plasma around the work piece. A tensional force can be applied to the support film. The tensional force can be applied to the frame. The tensional force can be a mechanical force, a magnetic force and/or an electrical force. The support film can be elastically deformed by the tensional force. The support film cannot be plastically deformed by the tensional force. A heat transfer fluid can be introduced between the support film and the work piece. The heat transfer fluid can be a gas such as helium. The fluid pressure can be greater than one Torr and can be less than thirty Torr. An electrostatic or mechanical chuck can be incorporated into the work piece support whereby the chuck can clamp the support film to the chuck. The clamping of the work piece can be performed after the tensional force is applied to the support film. The tensional force that is applied to the support film can be changed after the support film is clamped. The tensional force that is applied to the support film can be removed after the support film is clamped. The pressure within the process chamber can be reduced through the vacuum pump and a process gas can be introduced into the process chamber through the gas inlet. A plasma is generated through the plasma source whereby the work piece is etched through the generated plasma. A vacuum compatible transfer module can be provided that communicates with the process chamber. The work piece can be loaded onto a transfer arm in the vacuum compatible transfer module whereby the process chamber is maintained under vacuum during a transfer of the work piece from the vacuum compatible transfer module to the process chamber.
The foregoing has outlined rather broadly the more pertinent and important features of the present invention in order that the detailed description of the invention that follows may be better understood so that the present contribution to the art can be more fully appreciated. Additional features of the invention will be described hereinafter which form the subject of the claims of the invention. It should be appreciated by those skilled in the art that the conception and the specific embodiment disclosed may be readily utilized as a basis for modifying or designing other structures for carrying out the same purposes of the present invention. It should also be realized by those skilled in the art that such equivalent constructions do not depart from the spirit and scope of the invention as set forth in the appended claims.
BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a top down view of a semiconductor substrate illustrating individual devices separated by streets;
FIG. 2 is a cross-sectional view of a semiconductor substrate illustrating individual devices separated by streets;
FIG. 3 is a cross-sectional view of a semiconductor substrate mounted to tape and a frame;
FIG. 4 is a cross-sectional view of a semiconductor substrate mounted to tape and a frame being etched by a plasma process;
FIG. 5 is a cross-sectional view of separated semiconductor devices mounted to tape and a frame;
FIG. 6 is a cross-sectional view of a vacuum processing chamber;
FIG. 7 is a cross-sectional of a wafer/frame in process position;
FIG. 8 is an enlarged cross-sectional view of a frame and a cover ring in a vacuum processing chamber;
FIG. 9 is a cross-sectional view of a section of the inside the chamber with the cover ring mounted to a chamber wall;
FIG. 10 is a cross-sectional view of a section of the inside the chamber with the cover ring mounted to an internal heat sink;
FIG. 11 is a top down view of a semiconductor substrate mounted to tape and a frame supported by a transfer arm;
FIG. 12 is a cross-sectional view of a semiconductor substrate mounted to tape and a frame supported by a transfer arm;
FIG. 13 is a cross-sectional view of a wafer/frame in a transfer position;
FIG. 14 is a top view of a screen;
FIG. 15 is a cross-sectional view of an electrostatic chuck;
FIG. 16 is a schematic view of a chamber in a transfer position;
FIG. 17 is a cross sectional view of the work piece and work piece support;
FIG. 18 is a cross sectional view of the work piece and work piece support;
FIG. 19 is a cross sectional view of the work piece and work piece support;
FIG. 20 is a cross sectional view of the work piece and work piece support; and
FIG. 21 is a top down view of multiple semiconductor substrates mounted to tape and a frame.
Similar reference characters refer to similar parts throughout the several views of the drawings.
DETAILED DESCRIPTION OF THE INVENTION
A typical semiconductor substrate after device fabrication is illustrated in FIG. 1 . The substrate ( 1 ) has on its surface a number of areas containing device structures ( 2 ) separated by street areas ( 3 ) in which there are no structures which allows for separation of the device structures into individual die. Although silicon is commonly used as a substrate material, other materials chosen for their particular characteristics are frequently employed. Such substrate materials include gallium arsenide and other III-V materials or non-semi-conductor substrates on which has been deposited a semi-conducting layer.
In the present invention, as is shown in a cross sectional view in FIG. 2 , the device structures ( 2 ) are then covered with a protective material ( 4 ) while the street areas ( 3 ) remain unprotected. This protective material ( 4 ) can be a photoresist, applied and patterned by well-known techniques. Some devices, as a final process step are coated with a protective dielectric layer such as silicon dioxide or PSG which is applied across the whole substrate. This can be selectively removed from the street areas ( 3 ) by patterning with photoresist and etching the dielectric material, as is well known in the industry. This leaves the device structures ( 2 ) protected by the dielectric material and the substrate ( 1 ) substantially unprotected in the street areas ( 3 ). Note that in some cases test features to check the wafer quality may be located in the street areas ( 3 ). Depending on the specific wafer fabrication process flow, these test features may or may not be protected during the wafer dicing process. Although the device pattern illustrated shows oblong die, this is not necessary, and the individual device structures ( 2 ) may be any other shape, such as hexagons, as best suits the optimum utilization of the substrate ( 1 ). It is important to note that while the previous example considers dielectric materials as the protective film, that the invention may be practiced with a wide range of protective films including semi-conductive and conductive protective films. Furthermore, the protective layer can consist of multiple materials. It is also important to note that some portion of the protective film may be an integral part of the final device structure. (e.g., a passivation dielectric, metal bonding pad, etc.)
The substrate ( 1 ) may be thinned, typically by a grinding process, which reduces the substrate thickness to a few hundred microns to as thin as approximately 30 microns or less. As is shown in FIG. 3 , the thinned substrate ( 1 ) is then adhered to a tape ( 5 ) which in turn is mounted in a rigid frame ( 6 ) to form a work piece ( 1 A). The tape ( 5 ) is typically made from a carbon-containing polymer material, and may additionally have a thin conductive layer applied to its surface. The tape ( 5 ) provides support for the thinned substrate ( 1 ) which is otherwise too fragile to handle without breakage. It should be noted that the sequence of patterning, thinning and then mounting is not critical and the steps may be adjusted to best fit the particular devices and substrate and the processing equipment used. It is important to note that while the previous example considers a work piece ( 1 A) that is comprised of mounting a substrate ( 1 ) on an adhesive tape ( 5 ) which in turn is attached to a frame ( 6 ), that the invention is not limited by the configuration of the wafer and carrier. The wafer carrier can be comprised a variety of materials. The carrier supports the substrate during the plasma dicing process. Furthermore, the wafer need not be attached to the carrier using an adhesive—any method that holds the wafer to the carrier and allows a means thermal communication of the substrate to the cathode is sufficient. (e.g. an electrostatically clamped carrier, a carrier with a mechanical clamping mechanism, etc.)
While the example above describes mounting a single substrate ( 1 ) on adhesive tape ( 5 ) that is supported by a frame ( 6 ) to form a work piece ( 1 A), the invention can also be beneficially applied to a work piece ( 1 A) that is comprised of more than one substrate ( 1 ) mounted on adhesive tape ( 5 ) which is supported by a frame ( 6 ) as is shown in FIG. 21 . The substrates ( 1 ) can be different sizes, shapes, thicknesses and/or materials. It is preferable that if the substrates are different materials that they etch in similar etch chemistries (e.g. Ge and Si both etch in fluorine-based chemistries). The substrates ( 1 ) may have different areas of exposed materials and/or different patterns. Some of the substrates ( 1 ) may be pieces of larger substrates. It is preferred that the substrates ( 1 ) be located inside the inner diameter of the support frame ( 6 ). In one embodiment, the outer diameter of the support frame ( 6 ) is smaller than the outer diameter of the work piece support. After mounting the substrate ( 1 ) with the tape ( 5 ) in the dicing frame ( 6 ), the work piece ( 1 A) is transferred into a vacuum processing chamber. Ideally, the transfer module is also under vacuum which allows the process chamber to remain at vacuum during transfer, reducing processing time and preventing exposure of the process chamber to atmosphere and possible contamination. As shown in FIG. 6 , the vacuum processing chamber ( 10 ) is equipped with a gas inlet ( 11 ), a high density plasma source ( 12 ) to generate a high density plasma, such as an Inductively Coupled Plasma (ICP), a work piece support ( 13 ) to support the work piece ( 1 A), an RF power source ( 14 ) to couple RF power to the work piece ( 1 A) through the work piece support ( 13 ) and a vacuum pump ( 15 ) for pumping gas from the processing chamber ( 10 ). During processing, the unprotected areas of substrate ( 1 ) are etched away using a reactive plasma etch process ( 7 ) as shown in FIG. 4 . This leaves the devices ( 2 ) separated into individual die ( 8 ) as shown in FIG. 5 . In another embodiment of the invention, the unprotected areas of the substrate ( 1 ) are partially etched away using a reactive plasma etch process ( 7 ). In this case, a downstream operation, such as a mechanical breaking operation, can be used to complete the die separation. These downstream methods are well known in the art.
While the previous example describes the invention using a vacuum chamber in conjunction with a high density plasma, it is also possible to etch the unprotected areas of the substrate using a wide range of plasma processes. For example, one skilled in the art can imagine variations of the invention using a low density plasma source in a vacuum chamber or even the use of plasmas at or near atmospheric pressures.
When the substrate/tape/frame assembly ( 1 A) is in the position for plasma processing, it is important that the frame ( 6 ) is protected from exposure to the plasma ( 7 ). Exposure to the plasma ( 7 ) will cause heating of the frame ( 6 ) which in turn will cause local heating of the mounting tape ( 5 ). At temperatures above approximately 100° C., the physical properties of the tape ( 5 ) and its adhesive capability may deteriorate and it will no longer adhere to the frame ( 6 ). Additionally, exposure of the frame ( 6 ) to the reactive plasma gas may cause degradation of the frame ( 6 ). Since the frame ( 6 ) is typically re-used after wafer dicing, this may limit the useful lifetime of a frame ( 6 ). Exposure of the frame ( 6 ) to the plasma ( 7 ) may also adversely affect the etch process: for example the frame material may react with the process gas, effectively reducing its concentration in the plasma which will reduce the etch rate of the substrate material, thus increasing process time. To protect the frame ( 6 ), a protective cover ring ( 20 ), as shown in FIGS. 6, 7 and 8 , is positioned above the frame ( 6 ). The cover ring ( 20 ) does not touch the frame ( 6 ) since contact with the frame ( 6 ) (which would occur during transfer into the process chamber ( 10 )) can generate undesirable particles.
In FIG. 8 , dimension (A) represents the distance between the cover ring ( 20 ) and the frame ( 6 ). This dimension can range from less than approximately 0.5 mm to greater than approximately 5 mm with an optimal value of 1.5 mm. If the distance (A) is too large, plasma ( 7 ) will contact the frame ( 6 ) and the benefits of the cover ring ( 20 ) will be lost.
It is important that the cover ring ( 20 ) is temperature controlled, otherwise its temperature will increase due to exposure to the plasma ( 7 ) and in turn heat the tape ( 5 ) and the frame ( 6 ) via radiational heating, causing degradation as noted above. For the case where the cover ring ( 20 ) is cooled, cooling of the cover ring ( 20 ) is accomplished by having it in direct contact with a cooled body, such as the process chamber wall ( 10 W) shown in FIG. 9 or a heat sink ( 30 ) located within the process chamber ( 10 ) shown in FIG. 10 . To ensure that heat is adequately removed from the cover ring ( 20 ) to the heat sink ( 30 ), the cover ring ( 20 ) should be made of a material that has good thermal conductivity. Such materials include many metals, for example Aluminum, but other thermally conductive materials, such as Aluminum Nitride and other ceramics can be used. The choice of the cover ring material is chosen to be compatible with the plasma process gases used. While Aluminum is satisfactory for Fluorine based processes, an alternate material, such as Aluminum Nitride, or the addition of a protective coating, such as Aluminum Oxide may be necessary when Chlorine based processes are used. Operation temperature of the cover ring ( 20 ) during plasma processing is typically less than 80° C. which minimizes heat radiation to the tape ( 5 ) and the frame ( 6 ) and ensures that the tape ( 5 ) maintains its mechanical integrity. Alternatively, the cover ring ( 20 ) may be temperature controlled by bringing the cover ring ( 20 ) into contact with a temperature controlled fluid. This fluid can be a liquid or gas. In the case where the cover ring ( 20 ) temperature is controlled by a fluid, the cover ring ( 20 ) may contain a number of fluid channels to facilitate heat transfer. These fluid channels can be internal to the cover ring ( 20 ), externally attached, or some combination of the two.
In one instance, the cover ring ( 20 ) can extend from the substrate diameter to the inner chamber diameter continuously. To avoid a loss in pumping conductance, which can adversely affect pressure control within the process chamber ( 10 ), a plurality of holes ( 21 ) can be added to the cover ring ( 20 ) which allows sufficient conductance of the process gas while still providing a path for heat removal from the cover ring ( 20 ). In FIGS. 9 and 10 , a plurality of holes ( 21 ) arranged in a specific geometry is shown, but the density, size, pattern and symmetry of the holes ( 21 ) can vary depending on the process chamber ( 10 ) dimensions and the pumping conductance required.
The substrate/tape/frame assembly ( 1 A) is transferred both into and out of the process chamber ( 10 ) by a transfer arm ( 40 ) that supports the frame ( 6 ) and substrate ( 1 ) so that they are maintained coplanar as shown in FIGS. 11 and 12 . The transfer arm ( 40 ) may support both the tape ( 5 ) and the frame ( 6 ) or the frame ( 6 ) alone, but it is important that the assembly ( 1 A) not be supported beneath the substrate ( 1 ) area alone because of the fragile nature of thinned substrates ( 1 ). The transfer arm ( 40 ) has an alignment fixture ( 41 ) attached to it that aligns the frame ( 6 ) in a repeatable position before being transferred into the process chamber ( 10 ). The frame ( 6 ) can also be aligned by other techniques well-known in semiconductor processing (e.g., optical alignment). The alignment can also be performed on the substrate ( 1 ) by such well-known techniques. It is important that the substrate/tape/frame assembly ( 1 A) be aligned before placement within the process chamber ( 10 ) to avoid mis-processing as explained below.
In FIG. 8 , the dimension (D) represents the distance between the outer diameter of the substrate ( 1 ) and the inner diameter of the frame ( 6 ). This may be 20 mm to 30 mm (e.g., Disco Corporation dicing frame is 250 mm for 200 mm substrates, so that the dimension (D) is nominally 25 mm). During mounting of the wafer ( 1 ) on the tape ( 5 ) within the frame ( 6 ), the deviation of wafer ( 1 ) placement may be as much as 2 mm so that dimension (E), which is the distance between the substrate ( 1 ) outer diameter and the inner diameter of the cover ring ( 20 ) can also vary from assembly to assembly by up to 2 mm. If at some point (E) is less than zero the cover ring ( 20 ) will overlay the edge of the substrate ( 1 ). This point will be shadowed and prevented from etching, which can prevent die separation and cause problems in subsequent processing steps. Alignment of the substrate/tape/frame assembly ( 1 A) prior to transfer is required to prevent such problems. Further, to additionally ensure that dimension (E) is not less than zero, the cover ring inner diameter should be greater than the diameter of the substrate ( 1 ) with a preferred diameter 5 mm greater than the substrate (e.g., 205 mm cover ring inner diameter for 200 mm substrate). Dimension (F) in FIG. 8 represents the distance from the inner diameter of the cover ring ( 20 ) to the inner diameter of the frame ( 6 ). Alignment of the frame ( 6 ) prior to transfer into the process chamber ( 10 ) ensures that (F) remains constant for the entire circumference around the substrate ( 1 ) and that any portion of tape ( 5 ) that is not contacted by the Electrostatic chuck (ESC) ( 16 ) is shadowed from the plasma ( 7 ).
When the substrate/tape/frame assembly ( 1 A) is transferred into the process chamber ( 10 ), it is placed onto the lifting mechanism ( 17 ) and removed from the transfer arm ( 40 ). The reverse process occurs during transfer of the substrate/tape/frame assembly ( 1 A) out of the process chamber ( 10 ). The lifting mechanism ( 17 ) touches the frame ( 6 ) area and provides no point contact to the substrate ( 1 ). Point contact to the substrate ( 1 ) can cause damage to the substrate ( 1 ), particularly after die separation and unloading of the substrate/tape/frame assembly ( 1 A), since the flexibility of the tape ( 5 ) would cause the die to contact each other and damage to occur. FIG. 13 shows the lifting mechanism ( 17 ) contacting the frame ( 6 ) from the underside: however the frame ( 6 ) can also be removed from the transfer arm ( 40 ) by contact with the top surface or outer diameter using a clamping device. To process the substrate ( 1 ), the frame ( 6 ), the work piece support ( 13 ), and the cover ring ( 20 ) move relative to each other. This can be accomplished by moving either the cover ring ( 20 ), the work piece support ( 13 ), or the lifting mechanism ( 17 ) or any combination of the three.
While the tape ( 5 ) in the work piece ( 1 A) is typically under some tension—there are often imperfections (ripples, etc.) in the tape that can make it difficult to clamp the work piece ( 1 A) to the substrate support ( 13 A) sufficiently for effective helium backside cooling. In order to facilitate clamping of the work piece ( 1 A) to the work piece support ( 13 ) it is beneficial to construct the work piece support assembly ( 13 A) such that the flexible tape ( 5 ) is placed under additional tension while the clamping force is applied to the work piece ( 1 A). Preferably, the additional tension is applied to the tape ( 5 ) before the clamping force is applied. Once the tape ( 5 ) has been clamped, the additional tensioning force may be changed or removed.
One way in which this additional tensioning may be accomplished to configure the work piece support assembly ( 13 A) such that the surface defined by the frame/tape interface ( 50 as shown in FIG. 17 ) is located at or below the surface defined by the substrate/tape interface ( 55 as shown in FIG. 17 ). It is preferred that the some portion of the surface 50 is at least approximately 0.1 mm below some portion of the surface 55 . Some portion of the surface 50 can be at least approximately 1 mm below the surface 55 .
In another embodiment, all of the surface 50 is below the surface 55 . In this embodiment, it is preferred that the surface 50 is at least approximately 0.1 mm below the surface 55 . The surface 50 can be at least approximately 1 mm below the surface 55 .
In the case where the tape ( 5 ) is adhered to both the bottom surface of the substrate ( 1 ) and the bottom surface of the frame ( 6 ) this may be accomplished by ensuring that the top surface of the electrostatic chuck ( 16 ) is located at or preferably above the plane defined by the lower surface of the bottom of the frame ( 6 ) as shown in FIG. 17 . In this configuration, it is preferred that the top surface of the ESC is at least 0.1 mm above the bottom surface of the bottom of the frame ( 16 ). The work piece ( 1 A) may remain in this configuration during plasma processing or the additional tension may be changed at some point in the process. This configuration is particularly beneficial when the clamping force is applied by an electrostatic chuck. The additional tensioning may be applied through a number of hardware configurations. Note that while FIG. 17 shows the tape ( 5 ) being attached to the bottom of the support frame ( 6 ) that the method may still be beneficially applied to configurations where the tape ( 5 ) is applied to the top surface of the frame ( 6 ).
The force required to apply the additional tension to the tape ( 5 ) may be applied to the frame ( 6 ). The force may be applied to the top of the frame, the bottom of the frame or both. Some portion of the force required to apply the additional tension to the tape may be derived from the weight of the frame ( 6 ).
In one configuration, the tape frame ( 6 ) is supported by the lift mechanism ( 17 ) during clamping. The top surface of the process kit ( 18 ) will be at or below the plane of the top surface of the electrostatic chuck ( 16 ). The process kit may be in contact with the tape ( 5 ) and/or the frame ( 6 ). In the cases where the process kit is not in contact with the work piece, it is preferred that the gap between the work piece ( 1 A) and the process kit ( 18 ) is less than approximately 5 mm in order to prevent plasma formation in the space between the work piece ( 1 A) and the process kit ( 18 ).
In an alternate configuration, the tape frame is not supported by the lift mechanism ( 17 ) in order to tension the tape. In this configuration the frame ( 6 ) may be supported by the process kit ( 18 ), and/or a frame support member ( 17 A) as shown in FIG. 18 .
In yet another alternate configuration, the process kit may be incorporated into and/or replaced by extending the electrostatic chuck as shown in FIG. 19 . The tape frame ( 6 ) may be supported by the electrostatic chuck where the ESC surface supporting the substrate ( 1 ) is higher than the surface supporting the tape frame ( 6 ) placing the tape ( 5 ) under additional tension. In a preferred embodiment, a portion of the surface supporting the substrate ( 1 ) is at least 0.1 mm higher than the surface supporting the tape frame ( 6 ).
In yet another configuration, the inner diameter of the tape frame ( 6 ) is larger than the outer diameter of the work piece assembly ( 13 A). In this configuration the frame may be held by the lift mechanism ( 17 ) and/or an external tape frame support ( 17 A). Alternatively, the frame may be unsupported such that the weight of the frame contributes to the tensioning force.
While the examples above describe tensioning the tape in conjunction with an electrostatic clamp, the invention may also be beneficially applied to other clamping configurations, including mechanical clamping. In another embodiment the invention may also be beneficially applied to a work piece support assembly that does not utilize a clamping mechanism.
FIG. 20 shows yet another configuration. In this configuration the flexible tape ( 5 ) is stretched across the top surface of the work piece support ( 13 A) in order to form a seal between the tape ( 5 ) and the work piece support ( 13 A). A heat transfer fluid, typically helium gas is introduced between the tape ( 5 ) and the work piece support ( 13 A). The seal between the tape ( 5 ) and the work piece support ( 13 A) needs to be sufficient to support a heat transfer fluid pressure of greater than approximately 1 Torr but less than approximately 30 Torr between the tape ( 5 ) and the work piece support ( 13 A). It is preferable that the gas pressure behind the tape does not cause a separation between the tape ( 5 ) and the work piece support ( 13 A) greater than approximately 100 microns as this would adversely affect the heat transfer between the substrate and the work piece support. It is desired that the areas of tape under the substrate ( 1 ) and tape areas of the tape that are exposed to the plasma be inside the seal created between the wafer support assembly ( 13 A) and the tape ( 5 ). The force applied to the tape frame will put at least a portion of the tape ( 5 ) under tension—possibly deforming the tape ( 5 ). It is important to limit the applied force to the tape ( 5 ) such that the tape deformation does not preclude downstream packaging operations. Ideally, tensioning the tape ( 5 ) will result in only elastic deformation—though some amount of plastic deformation may be permissible provided it does not negatively impact downstream operations. The force required to create the seal between the tape ( 5 ) and the work piece support ( 13 A) may be applied to the tape frame ( 6 ). The force can be magnetic, mechanical, electrostatic, or some combination of the three. The force may be applied to the top of the frame, the bottom of the frame or both. Alternatively, the force can be applied directly to the tape, preferably in the areas not overlapping the substrate ( 1 ) or the frame ( 6 ). In yet another embodiment, an electrostatic force may be applied to the tape underneath the area covered by the substrate ( 1 ) in order to minimize the gap between the tape ( 5 ) and the work piece support ( 13 A). During plasma processing, heat is transferred to all of the surfaces the plasma ( 7 ) touches including the substrate ( 1 ), tape ( 5 ), and frame ( 6 ). The cover ring ( 20 ) will minimize the heat transfer to areas of the tape ( 5 ) and the frame ( 6 ), but the substrate ( 1 ) must remain exposed to the plasma ( 7 ) for processing. As shown in FIG. 6 , a conductive screen ( 25 ) (e.g., made from aluminum or aluminum coated with an appropriate plasma resistant coating) can be placed between the substrate ( 1 ) and the plasma ( 7 ). This will reduce ion bombardment on the substrate ( 1 ) and thus reduce heating of the substrate ( 1 ). FIG. 14 shows the screen ( 25 ) is provided with a plurality of holes ( 26 ) which still allows neutral species from the plasma ( 7 ) to reach the substrate ( 1 ) such that the etch rate is only slightly reduced. Holes ( 27 ) allow for mounting of the screen ( 25 ) to the processing chamber ( 10 ).
Additional cooling of the substrate ( 1 ) is provided by the use of an Electrostatic chuck (ESC) ( 16 ). Such ESCs ( 16 ) are commonly used in semiconductor processing to apply downward force to the substrate ( 1 ) while a pressurized gas such as Helium is maintained between the substrate ( 1 ) and the electrode. This ensures that heat transfer can occur between the substrate ( 1 ) and the electrode, which is cooled. Typically, ESCs ( 16 ) are the same diameter or smaller than the substrate ( 1 ) to prevent unwanted exposure of the ESC ( 16 ) surface to potentially corrosive plasma gases that can decrease the lifetime of the ESC ( 16 ). With a substrate/tape/frame assembly ( 1 A), the area outside the diameter of the substrate ( 1 ) is tape ( 5 ). Using a typical ESC ( 16 ), because the cover ring ( 20 ) is larger than the diameter of the substrate ( 1 ), there would be an area of tape ( 5 ) exposed to the plasma process that is not being clamped and cooled by the ESC ( 16 ) or being shielded from the plasma ( 7 ) by the cover ring ( 20 ). Such an area of tape ( 5 ) would reach a high temperature and possibly fail. Thus, FIG. 8 shows the use of an ESC ( 16 ) that is made purposely larger than the substrate diameter so that any tape ( 5 ) which is exposed to the plasma in region (E) is also clamped and cooled. This diameter can be extended outwards to the outer diameter of the frame ( 6 ), but is preferred to be 2 mm less than the inner diameter of the frame ( 6 ).
In the case where the work piece ( 1 A) contains more than one substrate ( 1 ), it is preferred that the ESC ( 16 ) extends beyond the edge of at least one substrate ( 1 )—preferably extending beyond the edges of all substrates ( 1 ). In order to confine the cooling gas (typically helium) behind the substrates the tape ( 5 ) must form a sealing surface between the work piece support ( 1 A) and the tape ( 5 ). This sealing surface is often called a seal band. The seal band is typically slightly higher than some portion of the area of the ESC that it circumscribes. In one embodiment the sealing surface is continuous and forms a shape that circumscribes all the substrates ( 1 ). In an another embodiment, the sealing surface may be discontinuous and circumscribes at least one region. It is preferred that a portion of the sealing band overlays a portion of ESC clamping electrode(s). In a preferred embodiment, all of the sealing band overlays a clamping electrode. The substrates ( 1 ) may overlay the sealing band(s) or alternatively, the sealing band(s) may lie outside the substrate(s) ( 1 )
FIG. 8 shows a filler ring ( 18 ) that extends from the outer diameter of the ESC ( 16 ) to the lifting mechanism ( 17 ). This filler ring ( 18 ) is used to prevent the back surface of any exposed tape ( 5 ) from being contacted by the plasma ( 7 ). Although a separate filler ring ( 18 ) is shown, an extension of the ESC ( 16 ) would also prevent plasma ( 7 ) exposure to the backside of the tape ( 5 ). The filler ring ( 18 ) is typically made of a dielectric material, such as a ceramic (e.g., Aluminum Oxide) or a plastic material, (e.g., polytetrafluoroethylene (PTFE, Teflon)) selected for both its low thermal conductivity and its low electrical conductivity. Typical ESCs ( 16 ) used in semiconductor processing have a pattern of shallow features fabricated on their surface to facilitate Helium distribution or to minimize contact with the backside of a substrate ( 1 ) to reduce particle formation. Such an ESC ( 16 ) can be used for plasma dicing when a substrate ( 1 ) is separated into multiple die, providing the feature dimensions on the ESC surface are smaller than the die size. When the die size approaches and becomes smaller than the ESC feature size, the tape will now conform to the features and flex, possibly causing the die to touch each other which can cause damage. The use of a substantially coplanar ESC surface eliminates this problem. Note that though the preceding example describes an ESC that cools the substrate, for some materials (e.g. approximately 180° C. for indium containing substrates) that require a higher temperature to facilitate the plasma etch process, a higher temperature controlled ESC ( 16 ) temperature may be desirable.
A typical ESC ( 16 ) (coulombic design of FIG. 15 ) consists of one or more electrodes ( 33 ) to which a high voltage ( 19 ) is applied, separated from the work piece support ( 13 ) by a thick insulating layer ( 32 ) and separated from the material to be clamped by a thin layer of dielectric material ( 34 ). The clamping force generated by electrostatic forces increases as the thickness of this dielectric layer ( 34 ) decreases and increases as the voltage applied increases. In the present instance, when the substrate ( 1 ) is mounted on an insulating tape ( 5 ), the thickness of the tape ( 5 ) adds to the total dielectric thickness interposed between the electrode ( 33 ) and the substrate ( 1 ). This total thickness should not be determined primarily by the tape thickness, since this is likely to vary, resulting in a variable clamping performance. Rather the ESC dielectric ( 34 ) should be relatively thick (of the order of a few 100 microns) to maintain a clamping performance independent of tape thickness. A high clamping force can be achieved by operating at a high clamping voltage (up to approximately 10 kV).
During plasma processing, RF power ( 14 ) is coupled to the substrate ( 1 ) to control ion bombardment on the substrate ( 1 ) and control the etch characteristics. The frequency of this RF may vary from 100's of MHz down to a few hundred kHz. When etching a substrate material down to an insulating layer (in this instance the mounting tape), problems with the etch associated with charging of the insulating layer are well known. Such problems include localized severe undercutting at the substrate/insulator interface which is undesirable during die separation, since this affects the performance of the singulated die. As is well known in the art, such charging problems can be reduced by operating at low RF frequencies and additionally pulsing or modulating the RF power at low frequency. Since RF coupling at such low frequency is not efficient through a thick dielectric material ( 32 ), the RF coupling to the substrate ( 1 ) is preferably via the one or more ESC electrodes, for example via a coupling capacitor ( 35 ) rather than via the RF powered work piece support ( 13 ). To maintain uniform RF coupling to the substrate ( 1 ), the ESC electrode or electrodes should also be uniformly disposed behind the substrate ( 1 ). This is difficult to achieve if multiple electrodes are used, since the necessary gaps between the electrodes result in a local variation in the RF coupling which adversely affects the quality of the etch, particularly the undercutting at the substrate/tape interface. A preferred embodiment of the ESC design therefore incorporates a so called monopolar design, in which a single electrode is used to provide the clamping force. Additionally, there should be as few as possible penetrations through this electrode (for example as for pin lifts) since these penetrations will also disturb the RF coupling and degrade the etch performance.
The substrate can be processed using techniques well known in the semiconductor industry. Silicon substrates are generally processed using a Fluorine based chemistry such as SF 6 . SF 6 /O 2 chemistry is commonly used to etch Silicon because of its high rate and anisotropic profile. A disadvantage of this chemistry is its relatively low selectivity to masking material for example to photoresist which is 15-20:1. Alternatively a Timed Division Multiplex (TDM) process can be used which alternates between deposition and etching to produce highly anisotropic deep profiles. For example, an alternating process to etch Silicon uses a C 4 F 8 step to deposit polymer on all exposed surfaces of the Silicon substrate (i.e., mask surface, etch sidewalls and etch floor) and then an SF 6 step is used to selectively remove the polymer from the etch floor and then isotropically etch a small amount of silicon. The steps repeat until terminated. Such a TDM process can produce anisotropic features deep into Silicon with selectivities to the masking layer of greater than 200:1. This then makes a TDM process the desired approach for plasma separation of Silicon substrates. Note that the invention is not limited to the use of fluorine containing chemistries or a time division multiplex (TDM) process. For example, silicon substrates may also be etched with Cl, HBr or I containing chemistries as is known in the art.
For III-V substrates such as GaAs, a Chlorine based chemistry is extensively used in the semiconductor industry. In the fabrication of RF-wireless devices, thinned GaAs substrates are mounted with the device side down onto a carrier, where they are then thinned and patterned with photoresist. The GaAs is etched away to expose electrical contacts to the front side circuitry. This well-known process can also be used to separate the devices by the front side processing described in the above mentioned invention. Other semiconductor substrates and appropriate plasma processes can also be used for the separation of die in the above mentioned invention.
To further reduce the problems associated with charging at the substrate/tape interface, the process can be changed at the point at which the interface is exposed to a second process which has less tendency to undercut and is typically a lower etch rate process. The point in time at which the change takes place depends upon the substrate thickness, which is likely to vary. To compensate for this variability, the time at which the substrate/tape interface is reached is detected using an endpoint technique. Optical techniques which monitor the plasma emission are commonly used to detect endpoint and U.S. Pat. Nos. 6,982,175 and 7,101,805 describe such an endpoint technique which is appropriate to a TDM process.
After singulation of the semiconductor substrate there can be unwanted residues that exist on the devices. Aluminum is commonly used as an electrical contact for semiconductor devices and when exposed to Fluorine based plasmas a layer of AlF 3 is formed on its surface. AlF 3 is nonvolatile under normal plasma processing conditions and is not pumped away from the substrate and out of the system and remains on the surface after processing. AlF 3 on Aluminum is a common cause of failure for devices because the bonding strength of wires to the electrical contacts is greatly reduced. Thus the removal of the AlF 3 from the surface of the electrical contacts after plasma processing is important. Wet methods can be used; however, this becomes difficult because of the fragile nature of the separated die, and the possible damage to the tape causing die release. Therefore, the process can be changed to a third process while the substrate is still within the vacuum chamber, to a process designed to remove any AlF 3 formed. U.S. Pat. No. 7,150,796 describes a method for in-situ removal of AlF 3 using an Hydrogen based plasma. Likewise, an in-situ treatment can be used to remove other halogen-containing residues when other halogen-containing gases are used to etch the substrate.
While the above examples discuss the use of plasma for separating die (dicing), aspects of the invention may be useful for related applications such as substrate thinning, plasma ashing, and bond pad cleaning.
The present disclosure includes that contained in the appended claims, as well as that of the foregoing description. Although this invention has been described in its preferred form with a certain degree of particularity, it is understood that the present disclosure of the preferred form has been made only by way of example and that numerous changes in the details of construction and the combination and arrangement of parts may be resorted to without departing from the spirit and scope of the invention.
Now that the invention has been described, | The present invention provides a method for plasma dicing a substrate, the method comprising providing a process chamber having a wall; providing a plasma source adjacent to the wall of the process chamber; providing a work piece support within the process chamber; placing a work piece onto the work piece support, said work piece having a support film, a frame and the substrate; loading the work piece onto the work piece support; applying a tensional force to the support film; clamping the work piece to the work piece support; generating a plasma using the plasma source; and etching the work piece using the generated plasma. | 65,247 |
"CROSS-REFERENCES TO RELATED APPLICATIONS \n [0001] This application is a non-provisional, (...TRUNCATED) | "Methods and apparatus are disclosed for occulting light. The occulter shape suppresses diffraction (...TRUNCATED) | 205,254 |
"BACKGROUND OF THE INVENTION \n [0001] 1. Field of the Invention \n [0002] (...TRUNCATED) | "The destruction of the rainforests in the last decades has become the biggest crime against humanit(...TRUNCATED) | 65,543 |
"RELATED APPLICATION \n This application is a continuation of U.S. patent application Ser. No. 1(...TRUNCATED) | "A system for encoding a video signal includes an input module to receive a media signal to be commu(...TRUNCATED) | 217,618 |
"CROSS-REFERENCE TO RELATED APPLICATIONS \n [0001] This application is a continuation of Se(...TRUNCATED) | "Substituted phenylcarbamoyl alkylamino arenes; substituted phenylthiocarbamyl alkylamino arenes; su(...TRUNCATED) | 130,354 |
"BACKGROUND \n [0001] A common environment scenario is mixed-mode, wherein differing versio(...TRUNCATED) | "Versioning management provides for efficient and effective handling of varying policy versions, cli(...TRUNCATED) | 95,596 |
"This application is a continuation of application Ser. No. 08/148,174, filed Nov. 4, 1993, which is(...TRUNCATED) | "Compounds of formula (I): ##STR1## in which: A and B are separately monoamines or together diamines(...TRUNCATED) | 124,074 |
"The following applications containing a common disclosure and concurrently filed with the present a(...TRUNCATED) | "A microprocessor comprising: an address data path; an arithmetic logic unit data path, said data pa(...TRUNCATED) | 163,247 |
"FIELD OF THE INVENTION \n [0001] The present invention relates to an image processing m(...TRUNCATED) | "A digital camera for generating a manipulated output image. The camera focuses an image using an au(...TRUNCATED) | 112,490 |
End of preview. Expand
in Dataset Viewer.
YAML Metadata
Warning:
empty or missing yaml metadata in repo card
(https://huggingface.co/docs/hub/datasets-cards)
- Downloads last month
- 5