JTAG
Hardware Debugger: Embedded JTAG Hardware Debug Tool
The JTAG PCB debugger for PowerPC, MIPS, XScale and ARM
processors,as well as FPGA, CPLD ASIC and other non-processor dsigns.
By combining the power of a JTAG
Hardware Test Tool, and a modern point-and-click GUI interface, the JTAG System helps
you
debug and deploy new prototype boards and systems faster than ever before.
Our
intuitive graphical user interface make even the most complex hardware test and debugging
tasks a snap.
JTAG
Debuggers Speed Your Development by Providing
the Following Services
New
Hardware/board Initialization
Hardware and Board
Initialization let's you send register values to your target
system over JTAG. For a new board with no boot ROM or FLASH, this is
the only way to get your target properly configured so that you can
begin to test your new hardware.
Using
Memory and register read/write services of the JTAG Debugger, you can
peek and poke your system to see what is working and what needs to be
addressed. Changing registers on-the-fly let's you try new settings
quickly to verify your system
JTAG
Memory Tests
JTAG Debug driven memory tests are built in allowing you to
do more extensive testing of your memory subsystem. These 'canned'
routines, save you the time and trouble of writing them yourself and
best of all, since they use JTAG, they are available as soon as you
plug into your target.
JTAG
Debugger Based FLASH Programming
Once you have verified that your target has clock, power and that basic
memory is accessible, you will want to program your target's FLASH
device Using your JTAG Debuggers built-in FLASH utilities. Agile-DB
provides extensive support for all popular
FLASH devices and support fast flexible FLASH operations like: Erase, Program, ID, and Verify.
Hot
Plug
Hot
Plug uses JTAG to let you plug in to your target while it is
running,and to take control of your target without disturbing its
state. Many JTAG debug tools must force a reset to take control, thus
losing valuable information.
Auto
ID
Auto
ID uses JTAG to detect the processor and FLASh device on your target
system.
Target Snapshot
BSDL
displays the state of each processor pin. This is useful to determine
why a system may have crashed.
LINUX
Debug Support
Embedded LINUX relies on a stable tested hardware platform. Using our JTAG and Embedded test produts you save vaiable time chasing phantom hardwareissues. Start with validated hardware andyou can focus on debugging your application. .
• JTAG Hardware Debugger
XJTAG hardware gives you the PC debug power of a traditional
In-circuit textsystem at a
fraction of the
price by leveraging the JTAG Boundary-Scan capability built into the hardware.
Benefits
• Works
With PowerPC, XScale, ARM, MIPS, Coldfire and CPU-32 Processors nd Non-Processor systems
• Easy
to Configure and Setup and Use
• Designed
for Resource Constrained PCs
• Supports
Board Bring-up Through Manufacturing Test
• Works
With the Tools You Need Today as Well as Tomorrow
• A
Powerful Command Line Interface
• Fast,
Flexible Downloads and FLASH Operations
• Turnkey
FLASH Libraries for All Popular Devices
• Built-In
Target Hardware Tests
• Complete
Help System and user Documentation
Please
follow the links below for more information:
»Supported
Processors
»Supported FLASH
Devices
Exceptional
Price/Performance
JTAG
Debuggers cost
a fraction of what you would pay for traditional In-Circuit
Emulators, yet provide as good
or better functionality
Works
with PowerPC,
MIPS, XScale and ARM Processors
Guardian-SE
can support multiple processor
families at one time. Keep one box on the shelf and never
waste time changing firmware just to change processors
UBoot
JTAG Debug Support
Uboot
is a popular boot loader used to boot Embedded LINUX. As UBoot starts
up, it copies itself from FLASH to RAM memory. This behavior requires
that the JTAG debugger can load multiple copies of the debug
information for u-boot: one for FLASH based debug, and one for RAM
based debug. Unfortunately, many debuggers do not handle multiple debug
files well. Without this feature, you would not be able to debug the full
boot process in one session. Agile-DB fully supports this
important feature. This feature is also crucial for debugging
Linux loadable modules.
Target
JTAG Initialization Support
JTAG
debuggers like Agile-DB, allow you to send a target memory and register
configuration
to your target over JTAG when you perform a reset command. This allows
you to get the target into a working state so that you can begin to
test it or run code. Agile-DB provides high-level GUI access to all
target registers, CACHE status and MMU settings, making it fast and
painless to create this file. Embedded Toolsmiths also provides ready-to-run
files for popular boards and evaluation kits
Manufacturing
Test Support
JTAG
Debug tools make for
excellent platforms for manufacturing test automation. Agile-DB has
programmable buttons, a powerful macro language and extensive FLASH
device support to help you initialize and test production hardware. Agile-Utilities
(a JTAG tool specifically ddesigned for board bring up and test
automation) is also perfect for test automation where full debugging is
not required.
Crash
Proof Debug
Using
JTAG debuggers to
see what caused your target to crash is very useful. Simply run your
target, then, after the crash you can see the target status: register,
cache, mmu values, the stack, etc.. Agile-DB also allow you to "hot
plug" into a running or crashed system without disturbing it's state.
Board/Hardware
Bring Up Support
JTAG
Debuggers are great for initial
hardware bringup. Just plug in and you are ready to peek and
poke your target system or run more advanced tests and user defined
macros.
Flash
Programming
JTAG
debuggers typically support FLASH programming
on your target by using target RAM to store the erase and program
routines. Agile-DB also provides versions of our FLASH utilities that
do NOT require working RAM--this is useful for new systems where RAM is
not yet set up.
Target
Snap Shots While Running
This
unique JTAG Debug
feature of Agile-DB let's you grab target memory, register, and
MMU/CACHE values from your target--even while it is still running.
Although this is not done in real-time, the operation will typically
not disturb the operation of your system.
Hot
Plug into a crashed or Running Target
The
JTAG Debug feature
let's you plug into your target at any time and view target values
without disturbing the target in the process.
Auto
ID of the Target Processor or FLASH Device
When
you plug into your
system, Agile-DB can use JTAG to automatically detect the processor
under test and the FLASH device on your target.
Powerful
ICE Commands and Macros
Automate
JTAG access to your target system, create new commands using our
powerful C-like language
Supports
Windows Host Systems
Use the development host you want to use, don't be forced to use what
the tool demands
These
tools were designed from the ground
up to help you get your embedded product to market fast. Our JTAG debug
products
offer the following benefits:
• Supports LINUX or Windows Host Systems
(Solaris and others using GDB)
• Supports Board Bring-up
Through
Manufacturing Test
• Products to Meet Every Budget and Need
• Optimized for Resource Constrained PCs
• Turnkey FLASH Libraries
included for All Popular Devices
• Full MMU/TLB Support--Including LINUX.
• Tested with U-Boot
and Popular Embedded
LINUX Distributions
• One System Supports All Processor
Families
• Scales to
Support Muti-Processor Debug
• Complete Help System and User
Documentation
|
|
