NoICE supports the original ARM7 and ARM/Thumb. It does not support Cortex or other modern variants.

JTAG

Probably the best way to use NoICE with the ARM7 is via JTAG. This requires the use of a JTAG pod, but allows in-circuit debugging of programs in Flash with little or no interference to the user program being debugged.

NoICE supports a variety of JTAG pods and interface methods, including

• Segger JLink (https://www.segger.com). The J-Link JTAG pod is available from Segger, from IAR under their own label, and it is included in IAR demo kits. NoICE will work with either the Segger or IAR versions of the J-Link.

• Macraigor Wiggler (http://www.macraigor.com). This is a parallel-port pod, also available in clone versions from Olimex (https://www.olimex.com/dev/arm-jtag.h) and others. NoICE can use these pods either via GDB server

• Olimex ARM-USB-OCD (https://www.olimex.com/dev/arm-usb-ocd.html) via GDB server such as OpenOCD.

• Amontec JTAG key (http://www.amontec.com/jtagkey.shtml) via GDB server such as OpenOCD.

• Signalyer (http://www.signalyzer.com) via GDB server such as OpenOCD.

• Any other JTAG pod for which you can find a GDB server interface.

Click here for more details.

Flash Burning

Flash burning is currently supported for the Philips LPC2xxx and the ST ST7xx families. We intend to support addition chips in the future, in most cases as they are requested by NoICE users. If your target isn't listed in the Target Chip drop-list, please contact us.

If your target is not supported in this version, you can still use NoICE to download and debug programs in RAM, or to debug programs burned into Flash by a vendor-supplied Flash burner

If you use NoICE to load a file that should reside in Flash, but on a target for which NoICE does not support Flash burning, NoICE will compare the data in the file to current Flash contents, and tell you if they differ. This can be a handy warning if you forget to run your vendor-supplied burner.

GDB Monitor

The lowest-cost way to use NoICE with target hardware is by using a target-resident GDB monitor stub. The cost is just an RS-232 port and enough Flash to hold the monitor, both often available on evaluation and demo boards.

This limits you to debugging programs in RAM, since the ARM's hardware breakpoints are available only via JTAG.

Please note that these limitations apply only to a monitor-based GDB server, and not to GDB servers in general: if you have a JTAG-based GDB server such as OpenOCD, hardware breakpoints and Flash burning are available.

Simulator

Instruction set simulation is quite straightforward. However, simulating the UARTs, timers, and other peripherals found on current microprocessors is a very complex task - at least if you want a good (i.e., useful) simulation. The cycle-by-cycle operation of these peripherals is seldom publicly documented, and anything less than a cycle-by-cycle simulation will mask problems which occur in real systems.

NoICE's ARM simulator provides simulation of ARM and Thumb instruction execution and a "simulated UART" so that you can use printf etc. The simulator does not do cycle-accurate simulation of a UART or simulate other peripherals such as timers or interrupts.

That said, the simulator can be very useful in debugging algorithms and becoming familiar with a processor without investing in any hardware.

More information here.