Computer Solutions Ltd
Whats New | Advanced Search
Downloads | Exchange Rates

Celebrating 40 years
supplying all your CAN and Embedded Development Tool needs


Keil Development Tools

Keil Software was founded in 1986.  Their product range is built around the ÁVision_IDE development environment with ANSI C/C++ compilers, Macro Assemblers, real-time executives, debuggers and simulators for embedded microcontrollers such as those from the ARM, 8051, 251 and C16x/ST10 families. They are now owned by ARM and are ARMs principle channel for development and distribution of C compilers for the ARM family.


Easy to learn and use, RealView MDK-ARM is a complete software development environment for ARM-based microcontrollers.


ARM Development Packages MDK-ARM
ÁVision_IDE X
ÁVision Debugger with Simulator X
RealView C/C++ Compiler from ARM X
ARM asm & ARM link X
GCC ARM Compiler X
Flash programming for ULINK X

Startup code for a range of chips

Extensive Programming Examples X



RealView« MDK-ARM Microcontroller Development Kit

This package is designed for the developer who requires the high performance compilation tools (fast optimised execution and minimum program size)  the RealView« compiler was developed by ARM to support their chip family and is now complimented by Keil's sophisticated JTAG debugging support.


ÁVision IDE

This is the Windows base Integrated Development Environment that co-ordinates Source Editing, Compiling, Linking and debugging.  The Windows based Integrated Development Environment from Keil combines project management, make facilities, source code editing, program debugging, and complete simulation in one powerful environment. The ÁVision development platform is easy-to-use and it helps you quickly create embedded programs that work. The ÁVision editor and debugger are integrated in a single application that provides a seamless embedded project development environment.

ÁVision Debugger

The Debugger supports debugging using your target system and a debugger interface (A ULINK JTAG interface for the ARM; an ICE or serial monitor for the 8051). ÁVision includes traditional features like simple and complex breakpoints, watch windows, and execution control as well as sophisticated features like trace capture, execution profiler, code coverage, and logic analyzer.

ÁVision Simulator

The ÁVision Simulator allows you to debug programs using only your PC with simulation drivers provided by Keil.  A good simulation environment, like ÁVision, does much more than simply simulate the instruction set of a microcontroller — it simulates your entire target system including interrupts, startup code, on-chip peripherals, external signals, and I/O.


RealView C/C++ Compiler (armcc)

  • ARM and Thumb« generation modes: You can mix ARM and Thumb code in the same source file. ARM mode allows for faster code operation making it ideal for interrupt handlers. Thumb mode provides the smallest code size.
  • Industry leading code size optimizations: Enables you achieve memory cost savings by generating the smallest compiled code size.
  • Industry leading code performance optimizations: Reduces power consumption by enabling increased through-put without clock speed increases.
  • Function Attributes for Hardware Support: The RealView C compiler provides function attributes that give you access to ARM hardware features, such as fast interrupt service routines in C.
  • Embedded Assembler: You may insert assembler code into C function definitions. This capability is necessary for fast DSP and other signal-processing algorithms. The RealView compiler supports full program optimization even when embedded assembler is used.
  • Function In-lining: You may speed-up execution of frequently called functions by using function in-lining. Inline functions are expanded inline without the overhead associated with function call, parameter passing, and return.
  • Parameter Passing in CPU Registers: The RealView compiler automatically uses CPU registers to pass most function arguments. It can even pass and return small C structures in registers.
  • Re-entrant Run-time Library: Most library routines are re-entrant and may be invoked from the main program thread and from interrupts. There is no need to include special protection schemes for library calls.
  • IEEE-754 Compliant Single and Double Precision Floating-point: High accuracy floating-point support.


RealView Macro Assembler (armasm)

  • Standard Macro Processor:  The macro processor supports assembler macros you may use to repeat or automate assembler instruction sequences.
  • Conditional Assembler Controls:  Conditional assembly allows you to control the assembler source code to create multiple target applications from the same source file(s).
  • Source Listing with Symbol Reference:  The listing file includes an optional cross reference that provides detailed information about the assembled source file.

RealView Linker (armLink)

  • Detailed Listing File:  The linker creates a comprehensive listing file that is easy to understand. It contains details like the memory configuration, input modules, memory map, symbol table, and cross reference.
  • Global Code Listing:  The linker generates a global code listing file that shows symbolic disassembly of the generated code.
  • Static Stack Analysis:  The linker calculates the stack requirements at link-time. This avoids run-time stack checking in the target application.


Versions of MDK Available are ......


The CortexM version supports the Cortex M0/0+/1/3/4 range only.

The Standard version includes support for most popular ARM variants ...ARM7/9, Cortex M0/0+/1/3/4, R4 & Securecore.

The Pro version includes support for most popular ARM variants ...ARM7/9, Cortex M0/0+/1/3/4, R4 & Securecore.
It also includes a Real time Kernel and libraries for TCP/IP, USB Device & Host, CAN, GUI and a Flash File System.



RTX-ARM Real-Time Kernel

A real-time kernel for ARM7, ARM9, and Cortex-M3 devices is an option, it allows you to create programs that simultaneously perform multiple functions or tasks. This is often required in an embedded application.  While it is certainly possible to create real-time programs without an RTOS (by executing one or more functions or tasks in a loop), there are numerous scheduling, maintenance, and timing issues that an RTOS solves for you. The RTX Real-Time Kernel allows flexible scheduling of system resources like CPU and memory and offers several ways to communicate between tasks.

Programs written for the RTX Real-Time Kernel use standard C constructs and are compiled with the RealView Compilation Tools provided in the MDK-ARM Development Kit. Additions to the C language allow you to easily declare task functions without the need for complex stack and variable frame configuration. Real-time programs written using the RTX Real-Time Kernel require only that you include a special header file and link the RTX library into your program.Keil ULINK JTAGE Interface Adapter

ULINK JTAG Interface

The Keil ULINK USB 2 Interface Adapter connects your PC's USB port to your target hardware (via JTAG, SWD, SWV or OCDS) and allows you to debug embedded programs running on target hardware. Support in  ÁVision is provided for ARM7/9/CORTEX. If you add a small code segment called the Real Time Agent to your application the ULINK2 and ÁVision IDE can supply a real time window onto memory watch addresses and inter task communications as well as a debugging terminal emulation.

The PRO version allows on-chip Real Time Data and Event trace for Serial Wire Viewer (SWV) where the chip supports that as well as Instruction and Event trace with Streaming Trace if ETM is supported (not on the ULINKpro-D)

 Flash Memory Programming is provided with flash programming algorithms supplied for common flash chips or via a user-configurable capability.

ARM evaluation boards + RealView Compiler

The Keil Evaluation Kits contain an evaluation board, a 16K code limited version of the RealView MDK-ARM Evaluation Tools, ULINK2 JTAG Debugger and sample applications which run on the CPU. Each evaluation board has a prototyping area and a JTAG Interface. These kits are a great introduction to help you get started writing programs and evaluating the microcontrollers and their capabilities.

Boards are available to support the NXP LPC1xxx, LPC2xxx, LPC4xxx,  Nuvotron, STMicro STM32, Toshiba TMPM  Follow this link for details of the boards and prices 



Keil Software development tools for the 8051 support every level of software developer from the professional applications engineer to the student just learning about embedded software. The industry-standard Keil tools support ALL 8051 derivatives and will help you get your projects completed on schedule.

8051 Development Packages PK51 CA51
ÁVision_IDE X X
A51 Macro Assembler X X
BL51 Code Linker/Locator/Converter X X
C51 C Compiler X X
ÁVision Debugger with Simulator or Target Monitor X  
RTX51 Tiny Real-time Kernel X  

Far Code/Data Support for Dallas 390, Philips 51MX, Analog Devices ADuC812
is available using AX51 Macro Assembler, CX51 C Compiler, LX51 Linker



A51 Macro Assembler

This powerful 8051 macro assembler translates symbolic assembly language mnemonics into relocatable object code where the utmost speed, small code size and hardware control are critical.  The debug option provides information to support debugging with the ÁVision Debugger or an in-circuit emulator.

BL51 Code Banking Linker

This combines OMF51 object modules and creates executable 8051 programs.  It supports common 8051 memory banking strategies (not Dallas 390 or Philips 51MX).  Also included are OH51 Object-HEX Converter which creates Intel HEX files from absolute OMF51 object modules and the OC51 Banked Object Converter which creates an absolute object module for each code bank in a banked object module.

C51 C Compiler

This is the most popular 8051 C compiler in the world.  It provides more features than any other 8051 C compiler available today and language extensions give you full access to all resources in the 8051.  The C51 Compiler translates C source files into relocatable object modules which contain full symbolic information for debugging with the ÁVision Debugger or an in-circuit emulator.

  • Nine basic data types, including 32-bit IEEE floating-point
  • Flexible variable allocation with bit, data, bdata, idata, xdata, and pdata memory types
  • Interrupt functions may be written in C
  • Full use of the 8051 register banks
  • Complete symbol and type information for source-level debugging
  • Use of AJMP and ACALL instructions
  • Bit-addressable data objects
  • Support for dual data pointers
  • Built-in interface for the RTX51 real-time operating system
  • Support for the Philips 8xC750, 8xC751, and 8xC752 limited instruction sets
  • Support for the Infineon 80C517 arithmetic unit


Target Monitor

Simulation will solve many development problems and a ROM Emulator will speed up your development turnaround time if you are using external memory.  An ICE is nice if you can afford one.  But if these are not viable then the PK51 package includes a number of monitor programs (for different memory situations) which can provide a limited debug environment.  They all work by using the 8051's serial link to connect to the ÁVision Debugger which can then control downloading of code into the 8051, setting breakpoints reporting variables and running code.  The most straightforward of the monitors are MON51 which takes 5KBytes of code space and will only debug code if it can be put into von Neumann mapped RAM space on the target and MON390 which is designed to do the same for Dallas DS80Cxxx boards.  FlashMON51 will perform the same functions but can debug code in IAP flash memory and ISD51 will operate with the smallest on chip applications such as the Philips LPC series.

Far Data and enhanced instruction sets

The PK51 package includes a number of tools for developing code for the extended 8051 architectures of the Dallas 390, Philips 51MX and  Analog Devices ADuC812.

AX51 Macro Assembler is an enhanced 8051 assembler that provides support for 8051-based devices with additional instructions and features.  It supports the Dallas Contiguous Mode Instruction Set (390/5140/400) and the Philips 51MX Instruction Set.

The CX51 C Compiler is an ANSI Standard C Compiler for the Philips 51MX architecture which support linear memory models (8MBytes code and 8MBytes data).

The LX51 Enhanced Linker/locator will operate with conventional and extended compilers and supports SROM class for segments that need to be copied from ROM for execution, provides detailed type checking and XDATA constants as well as supporting the enhanced banking capabilities of the 51MX and Dallas chips.


  • Designed for single-chip applications where code size is the most important factor and no XDATA is available
  • Not a full Real Time operating system as it only supports round-robin and co-operative multitasking. It does not include Pre-emptive task switching or task priorities - for which see CMX's Real Time Operating System for the 8051
  • None-the-less it may be suitable for simple applications that don't need features like messaging, semaphores and memory pool management
  • Requires only 900 bytes of code space
  • Can be used with any 8051 target system as it supports all memory models of the C51 Compiler (SMALL, COMPACT and LARGE)


251 and 166/S10

Compilers and Debuggers for these CPUs provide similar features to the C51 C Compiler and operate within the same ÁVision_IDE - call/email CPU specific details.


For prices of Keil products email


Home Shop Products Information Zone Contact Site Map
Computer Solutions Ltd
17 Sandy Road,  Addlestone, Surrey   KT15  1HZ
Telephone: +44 (0) 1932 829460    
Email:      Web:
Copyright ę 2019 Computer Solutions Ltd