MicroController Pros Home Page My Account  Cart Contents  Checkout  
  Store » ARM » JTAG Debuggers » 8.16.28 My Account  |  Cart Contents  |  Checkout   
Quick Find
Enter keywords to find the product you are looking for in the Quick Find field above

or use
Advanced Search
Accessory Boards->
ADI Blackfin
  JTAG Debuggers->
  Starter & Evaluation Kits
Atmel AVR->
Cypress PSoC
Microchip PIC->
Silicon Labs
ST Microelectronics->
Texas Instruments->
Embedded Ethernet->
Embedded Software->
I/O Modules->
Parts & Components->
Pick & Place Tools
Programmable Logic (PLD)
Prototype PCBs->
ROM/Flash Emulators
Test & Measurement->
Tutorial Software
Universal Programmers->
Intro to Embedded Tools
Embedded News Digest
Useful Resources
Shipping & Returns
Warranty & Liability
Privacy Notice
Conditions of Use
Contact Us
J-Link ULTRA+, High-Speed USB JTAG Debugger with Software US$400.00

J-Link ULTRA+, High-Speed USB JTAG Debugger with Software

The J-Link ULTRA+ is an enhanced version of the J-Link ULTRA JTAG In-Circuit Debugger/Programmer. This version includes integrated licenses for the J-Flash software, the RDI Interface software, and the Flash Breakpoints component. Thus you save over $1100 off the cost of purchasing each component separately!

J-Link ULTRA+ is a JTAG/SWD emulator designed for ARM/Cortex and other supported CPUs. It is fully compatible to the standard J-Link and works with the same PC software, but offers even higher speed as well as target power measurement capabilities due to the faster CPU, built-in FPGA and High-Speed USB interface. View J-Link ULTRA Speed Demonstration.

It connects via USB to a PC running Microsoft Windows 2000, Windows XP, Windows 2003, Windows Vista or Windows 7. J-Link ULTRA+ has a built-in 20-pin JTAG/SWD connector. Adapter cables are available for other programming interfaces.

J-Link ULTRA+ Features

  • Supported CPUs: Any ARM7/9/11, Cortex-A5/A8/A9, Cortex-M0/M1/M3/M4, Cortex-R4, RX610, RX621, RX62N, RX62T, RX630, RX631, RX63N
  • Download speed up to 3 MBytes per second
  • High-speed USB 2.0 interface
  • Serial Wire Debug (SWD) support
  • Serial Wire Viewer (SWV) support
  • SWV: UART and Manchester encoding supports
  • SWO sampling frequencies up to 25 MHz
  • Target power supply: J-Link can supply up to 300 mA to target with overload protection
  • Target power consumption can be measured with high accuracy
  • Direct download into Flash memory of most popular microcontrollers supported
  • Automatic core recognition
  • JTAG speed up to 60 MHz
  • Supported by all major IDEs such as IAR EWARM, Keil MDK, Rowley CrossWorks, Atollic TrueSTUDIO, IAR EWRX, Renesas HEW, Renesas e2studio, etc.
  • No power supply required; powered through USB
  • Support for adaptive clocking
  • All JTAG signals can be monitored; target voltage can be measured
  • Supports concurrent access to CPU by multiple applications (see below)
  • Cross-platform support (limited use on Linux and Mac; see below)
  • Intelligence in the emulator firmware (communication handled on the J-Link not on the PC side)
  • Remote Server included (allows using J-Link remotely via TCP/IP)
  • GDB Server included (see below for details)
  • Supports multiple target interfaces: JTAG, SWD
  • Supports SWV/SWO (Serial Wire Viewer / Serial Wire Output)
  • Wide target voltage range: 1.2V - 3.3V, 5V tolerant
  • Supports JTAG chains with multiple devices
  • Embedded Trace Buffer (ETB) support
  • Fully plug-and-play compatible
  • Standard 20-pin JTAG connector
  • USB and 20-pin ribbon cable included
  • Optional Software Developer Kit (SDK) available
  • Optional Adapters available for 14-pin ARM, 14-pin TI OMAP, 9-pin and 19-pin Cortex-M, and Renesas RX micros
  • Optional optical isolation adapter available
J-Link allows multiple applications to have access to the CPU at the same time. This has numerous advantages. For example: J-Link Commander can be used in parallel with a debugger; a tool to communicate via DCC can be used in parallel with a debugger; or a visualization tool such as Micrium's u/C-Probe or Segger's kernel viewer embOSView. (This feature currently is not available for Cortex-A or Cortex-R cores.)

On Mac and Linux, only the following components are supported: J-Link Commander, command-line GDB Server, shared library (DLL equivalent).

  • Download J-Link Documentation
  • J-Link Software

    In additional to the larger software components mentioned in detail on this page, the following free software tools are included in the J-Link software package:

    J-Link Configurator is a utility to manage multiple J-Links connected to the PC via USB or Ethernet.

    J-Link Commander is a simple command-line utility primarily for diagnostics and troubleshooting.

    J-Link Remote Server allows a J-Link to be used remotely via TCP/IP. This enables you to connect to and fully use a J-Link from another computer. Performance is just slightly (about 10%) lower than with direct USB connection.

    SWO Viewer shows terminal output of the target perfomed via SWO pin.

    J-Mem displays memory contents of ARM systems and allows modifications of RAM and sfrs (special function registers) while the target is running. This makes it possible to look into the memory of an ARM chip at run time; RAM can be modified and sfrs can be written. The type of access for both read and write can be selected to be 8/16/32-bit. It works nicely when modifying sfrs, especially because it writes the sfr only after the complete value has been entered.

    J-Link DLL Updater makes sure you have the latest DLL which allows third-party applications to use the J-Link.

    Dedicated flash programming utilities (DFPU) for a number of popular evaluation boards.

  • Download J-Link Software
  • J-Link GDB Server

    The J-Link GDB Server translates the monitor commands from your GDB-capable Integrated Development Environment into commands understood by the J-Link ARM. As such it allows you to use the J-Link with any ARM Toolchain and IDE that supports GDB. It supports transfer of SWO data (terminal output, instrumentation trace, PC samples, etc.).

    User interface

    The J-Link GDB Server's graphical user interface shows information about the debugging process and the target connected via JTAG, including:
    • Host IP address that is connected to the J-Link GDB Server
    • Connection status of J-Link
    • Information about the target core
    • Measured target voltage
    • Bytes that have been downloaded
    • Status of target
    • Log output of the J-Link GDB Server (if Log window is checked)
    • Initial and current JTAG speed
    • Target endian setting
    There also is a command-line version available for Linux, Mac and Windows.

    Supported cores

    Currently the J-Link GDB Server can be used with the following CPU cores: ARM7, ARM9, ARM11, Cortex-A5, Cortex-A8, Cortex-A9, Cortex-M0, Cortex-M0+, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-R4, RX610, RX621, RX62N, RX62T, RX630, RX631, RX63N.

    Supported remote commands

    J-Link GDB Server supports several remote commands from the GDB. These commands can be used from within a .gdbinit file or the GDB console to initialize the target board and to set up J-Link GDB Server specific parameters.
    Command Function
    ClrBPRemoves an instruction breakpoint.
    EndianSets endianess of the target.
    GoStarts the target CPU.
    HaltHalts the target CPU.
    JTAGConfConfigures a JTAG scan chain with multiple devices on it.
    LongReads or writes from/to given address.
    RegReads or writes from/to given register.
    ResetResets and halts the target CPU.
    SelectSelects the way J-Link is connected to host system.
    SetBPSets an instruction breakpoint at a given address.
    SleepSleeps for a given time period.
    SpeedSets the JTAG speed of J-Link / J-Trace.
    StepPerforms one or more single instruction steps.
    WaitHaltWaits for target to halt code execution.
    WIceWrites to given IceBreaker register.

    J-Flash ARM Software

    J-Flash is a software application for Windows systems which enables you to program your Flash EEPROM devices via the On-Chip Debug connector (JTAG) on your target system, when used with the J-Link. View J-Flash Introduction Video.

    J-Flash works with any ARM system and supports all common external Flash devices, as well as the programming of internal Flash in ARM microcontrollers. It allows you to ERASE, FILL, Program BLANK CHECK, CHECKSUM, UPLOAD Flash content, and VIEW MEMORY functions of the software with your Flash devices.

    J-Flash Programming Software Features

    • Works with any ARM7/9/11 and Cortex-M0/M3 core
    • Supports internal Flash of most popular microcontrollers
    • Supports CFI-compliant NOR flash (combinations 18x, 2x8, 1x16, 2x16)
    • Supports most non-CFI compliant NOR flash devices (combinations 18x, 2x8, 1x16, 2x16)
    • Can support SPI NOR-Flash, NAND Flash, and Atmel DataFlash (see note below)
    • Multi-bank programming support (only with Flasher-ARM hardware in standalone mode)
    • High-speed programming: up to 150 kByte/sec (depending on device)
    • Very high blank-check speed: Approx. 16 Mybtes/sec (depending on target)
    • Smart read-back: Only non-blank portions of Flash transferred and saved
    • Easy to use; comes with projects for standard eval boards

    After installing the J-Link driver and J-Flash, simply connect your J-Link to your PC and start the J-Flash executable. Project files for common CPUs and Eval boards are provided. If you do not find an existing project file for your selected CPU, it is easy to write and save your own project file: Simply choose Option|Project from the Menu and select the right settings for your target hardware.

    Support for Atmel DataFlash, NAND Flash, SPI-NOR Flash

    Since the connection of these Flashes varies from microcontroller to microcontroller, there are always some modifications which are necessary to get DataFlash/NAND/SPI-NOR Flash supported on a specific hardware. The J-Flash software comes with sample projects which allow programming the DataFlash/NAND Flash on popular evaluation boards. If you have a hardware design which is based on one of these eval boards, these sample projects should work for your hardware also. If your hardware design varies too much, then a custom RAMCode will be needed to program the Flash of your target hardware. A RAMCode template is available to help you write your own.

    J-Flash Programming Software Supported Devices

    J-Flash can program external as well as internal Flash. Any combination of ARM CPU and external Flash is supported if the Flash chip is in the complete lists of supported microcontrollers and external Flash devices. As well as the listed Flash chips, every CFI-compliant chip is supported. In addition, all types of Flash interfacing are supported: 1 x 8-bit, 2 x 8-bit, 4 x 8-bit, 1 x 16-bit, 2 x 16-bit, 1 x 32-bit.

  • Download J-Flash User Manual
  • J-Link RDI Interface

    The J-Link RDI interface makes it possible to use the J-Link ULTRA+ with any RDI-compliant debugger. The package consists of two DLLs which need to be copied to the debugging software's program folder and selected in your debugger software. The following RDI-compliant debuggers have been tested with J-Link RDI: ARM Developer Suite (ADS), ARM RealView Development Suite (RVDS) V3.0 (not V3.1 or above as RDI support has been withdrawn), IAR Embedded Workbench for ARM (EWARM), and RealView MicroController Development Kit (Keil MDK).

    J-Link RDI Software Configuration

    RDI allows various configuration settings, such as
    • Target system initialization via setup file
    • JTAG Speed and scan chain settings
    • Enable / disable Flash programming
    • Breakpoint settings (use software breakpoints; use Flash breakpoints
    • CPU-specific settings (Endianness; Reset strategy)
    Normally, the default settings can be used. The Speed field allows the selection of a fixed JTAG speed. Via setup file, the target system can be initialized in just about any way required.

    Setup File Commands:

    Command Description
    SetJTAGSpeed(x); Sets the JTAG speed, x = speed in kHz (0=Auto)
    Delay(x); Waits a given time,
    x = delay in milliseconds
    Reset(x); Resets the target,
    x = delay in milliseconds
    Go(); Starts the ARM core
    Halt(); Halts the ARM core
    Read8(Addr); Reads a 8/16/32 bit value,
    Addr = address to read (as hex value)
    Verify8(Addr, Data); Verifies a 8/16/32 bit value,
    Addr = address to verify (as hex value)
    Data = data to verify (as hex value)
    Verify16(Addr, Data);
    Verify32(Addr, Data);
    Write8(Addr, Data); Writes a 8/16/32 bit value,
    Addr = address to write (as hex value)
    Data = data to write (as hex value)
    Write16(Addr, Data);
    Write32(Addr, Data);
    WriteVerify8(Addr, Data); Writes and verifies a 8/16/32 bit value,
    Addr = address to write (as hex value)
    Data = data to write (as hex value)
    WriteVerify16(Addr, Data);
    WriteVerify32(Addr, Data);
    WriteRegister(Reg, Data); Writes a register
    WriteJTAG_IR(Cmd); Writes the JTAG instruction register
    WriteJTAG_DR(nBits, Data); Writes the JTAG data register

    Example setup file:

    * Setup file for J-LINK RDI
    * File: LPC2294.setup
    * Purpose: Setup for Philips LPC2294 chip
    Write32(0xE01FC040, 0x00000001); // Map User Flash into Vector area at (0-3f)
    Write32(0xFFE00000, 0x20003CE3); // Setup CS0
    Write32(0xE002C014, 0x0E6001E4); // Setup PINSEL2 Register

  • Download J-Link RDI User Manual
  • Flash Breakpoints License

    The Flash Breakpoints license allows you to set an unlimited number of software breakpoints in Flash memory areas, rather than just the 2 hardware breakpoints. A RAM code, specially designed for this purpose, sets and clears Flash breakpoints extremely fast; on micros with fast Flash the difference between breakpoints in RAM and Flash is hardly noticeable. In addition, a combination of software and hardware breakpoints, as well as a built-in instruction set simulator, reduces the number of Flash operations that need to be performed. This minimizes delays for the user, maximizing the lifetime of the Flash. All resources of the ARM micro are available to the application program; no memory is lost for debugging. View Flash Breakpoints Demonstration.

  • Download Comparison Sheet to see the differences between the various J-Link and J-Trace models.
  • Ships from: USA
    Leadtime: In stock

    Optional Recommended Products for this Item
    20-pin to 14-pin Adapter for ARM JTAG In-Circuit Debuggers+ US$12.50
    20-pin to 14-pin Adapter for ARM JTAG In-Circuit Debuggers+ US$12.50
    20-pin to 14-pin Adapter for ARM JTAG In-Circuit Debuggers+ US$12.50
    20-pin to 14-pin Adapter for ARM JTAG In-Circuit Debuggers+ US$12.50
    20-pin Standard to 10-pin Cortex Adapter for ARM JTAG Programmer+ US$10.00
    20-pin Standard to 20-pin Cortex SWD Adapter for ARM JTAG+ US$7.00
    J-Link 14-pin TI OMAP Adapter+ US$35.00
    J-Link Renesas RX Adapter+ US$19.00

    This product was added to our catalog on Thursday 18 August, 2016.


    Shopping Cart more
    0 items
    What's New? more
    Flowcode 7 "Input/Output Pack" Feature Pack
    Flowcode 7 "Input/Output Pack" Feature Pack
    Tell A Friend

    Tell someone you know about this product.
    Notifications more
    NotificationsNotify me of updates to J-Link ULTRA+, High-Speed USB JTAG Debugger with Software
    Reviews more
    Write ReviewWrite a review on this product!
      Tuesday 11 May, 2021   List of all our Products

    Copyright © 2003-2017 MicroController Pros LLC
    Powered by osCommerce