MON166 User's Guide

MON166 is a debug monitor for C16x and ST10 user programs. It consists of:

• A configurable monitor program that resides and runs on your target system.
• The µVision Debugger and its associated MON166 driver.

The code space requirements of MON166 are small. It can run from about 5K of external or on-chip CODE memory.

It requires only 256 bytes of RAM for monitor variables and storage.

To debug programs with MON166, you must configure the monitor for your specific target system (which has several requirements).

Then, you must alter the load/starting address of your target program and download it to your target system using MON166 and the µVision Debugger.

MON166 offers the following features:

• Controlled program execution with single-stepping and multiple software breakpoints.
• Ability to view and change CPU registers and memory.
• Access to Special Function Registers (SFRs).
• Full speed execution of user programs.

The MON166 Monitor has the following requirements:

• MCU compatible with 80C166, C161, C163, C164, C165, C167, or ST10.
• Software trap for breakpoints (NMI is typical).
• Ten (10) words of stack space in the user program being tested.
• 256 bytes of off-chip data memory (RAM).
• 5K bytes of off-chip code memory (ROM) loaded with the MON166 monitor. RAM may be used with the MCU in bootstrap mode.
• Serial interface. 
  This may be the on-chip UART, 
  a simulated UART (using two port pins), 
  or an external UART (like the 16450 or 16550 used on standard PC's).
  MON166 requires only the TRANSMIT DATA and RECEIVE DATA RS-232/V.24 signals along withGROUND. 
  In some cases, additional connections are necessary to enable communications 
  (for example, loop-back connections for DTR, DSR, RTS, CTS, and DCD). 

There are a few restrictions to using the MON166 Monitor to debug your target programs.

• The memory mapping of a CPU board with MON166 is selected with hardware components and the Monitor configuration file.
  It is not possible to use Debug — Memory Map to change the memory mapping of the target system.
• The Performance Analyzer, Call Stack, Code Coverage, and Step Out capabilities are not available.
• The View — Periodic Window Update option is not available.
• Breakpoint Options are handled directly by MON166.
  However, when access or conditional breakpoints are set,
  the application is executed in single steps and not in real time.
  Single-step execution is at least 1,000 times slower then real time execution.

Using the monitor requires proper setup and configuration of two distinct applications:

the MON166 Target Monitor program and the µVision IDE and Debugger.

• MON166 is a program that resides on your target system.
  It may be programmed into EPROM, ROM, EEPROM, FLASH, non-volatile memory, or RAM.
  It communicates with the µVision Debugger and allows you
  to download programs (to RAM), set breakpoints,
  watch memory areas and program objects, and so on.
  When programmed into ROM, MON166 starts running when you reset your target system.
  When using your MCU in bootstrap mode, MON166 downloads when you start the µVision Debugger.
  
  
• The µVision Debugger begins a debugging session with the monitor
  by establishing serial communication with the MON166 program running on the target system.
  The target program being debugged in µVision is transmitted to MON166 and is written into RAM (by MON166).
  Once the target program has been downloaded, you may proceed to step through it, set breakpoints, and so on.
  
  All operations performed in the µVision Debugger are communicated to MON166 using a proprietary serial protocol.
  MON166 serial commands are NOT ASCII text-based and cannot be easily viewed or created with a terminal program
  — the µVision Debugger and MON166 driver are required.

Debugging programs with MON166 has some side-effects:

• MON166 can be configured to use the on-chip UART.
  The target program may use the on-chip UART as long as the UART configuration is not changed.
  If the serial port, timer, or baud rate configuration are changed,
  the monitor will lose communication with the µVision Debugger.
  Characters transmitted by the target appear in the µVision Serial Window.
  Note that the Stop Program Execution with Serial Interrupt Option must not be checked
  if your target program uses the serial port.
  
  
• You may use the serial interrupt to signal MON166 to halt program execution.
  If you enable this option, your target program cannot use the on-chip UART.

MON166 is easily adapted to a wide variety of target hardware.

Several µVision projects are provided to help you quickly configure the monitor for your target system.

These are found in the \KEIL\C166\MONITOR\ folder.

USER166\USER_166.UV2 : User configuration files for 8xC166 CPU and ST10-166.

USER167\USER_167.UV2 : User configuration files for all other CPU variants, like C161, C163, C164, C165, C167, and ST10.

Bootstrap Mode

In bootstrap mode, MON166 is downloaded into RAM of the target system.

This is typically the best mode to start with since the MCU auto-adjusts the serial port baudrate

and does not require you to program an EPROM.

In this mode, the MCU communicates with the PC using the built-in ASC0 UART.

UART Mode

In UART Mode, MON166 is programmed into FLASH memory or an EPROM.

Compared to the Bootstrap Mode, UART Mode saves the download time for MON166.

In this mode, the MCU communicates with the PC using the built-in ASC0 UART or ASC1 UART which is available on some devices.

You may configure that UART for an exact baudrate or you may use auto-baudrate detection.

Simulated Serial Mode

In Simulated Serial Mode, MON166 is programmed into FLASH memory or an EPROM.

This mode does not use any of the on-chip peripherals, but has the restrictions

that you cannot use the uVision HALT toolbar command to stop program execution since there is no serial interrupt.

Tha advantage is that your target program has complete use of the ASC0 UART.

In this mode, the MCU communicates with the PC using two (2) unused I/O pins.

Code in the monitor toggles the transmit pin to send serial characters one bit at a time.

Code to receive serial characters listens for one bit time and determines the character received.