8051 Professional Developer's Kit with C-51 C Compiler, A51 Assembler, 8051 Banking Linker, Tiny Real Time Operating System for 8051, 8051 Simulator and 8051 Debugger
The PK51 Professional Developer's Kit for the 8051 microcontroller family supports all 8051 derivatives including new devices with extended instruction sets and address space (like the Dallas 390/5240/400, Philips 51MX, and Analog Devices MicroConverters) and classic 8051-compatible devices and IP cores from companies like Analog Devices, Atmel, Cypress Semiconductor, Dallas Semiconductor, Goal, Hynix, Infineon, Intel, OKI, Philips, Silicon Labs, SMSC, STMicroelectronics, Synopsis, TDK, Temic, Texas Instruments, and Winbond.
The following components are included in the PK51 8051 Professional Developer Kit:
RTX51 TINY Real-Time Kernel
RTX51 TINY is a small real-time kernel designed for single-chip applications where code size is the most important factor. The RTX51 Tiny kernel requires only 900 bytes of code space and is well suited for applications that don't need RTOS features like messaging, semaphores, and memory pool management.
RTX51 TINY was designed for single-chip applications where no XDATA is available. However, RTX51 TINY may be used with any 8051 target system.
RTX51 TINY supports all memory models of the C51 Compiler (SMALL, COMPACT, and LARGE). Operating system variables and task stacks are stored in internal DATA/IDATA memory.
RTX51 Tiny performs round-robin and cooperative multitasking only. Pre-emptive task switching and task priorities are not supported. If you need these features, you should consider RTX51 Full.
RTX51 Tiny uses Timer 0 for the operating system timer tick. No other hardware resource is used.
MON51 and MON390 Target Monitors
MON51 and MON390 are full-featured, license-free, royalty-free target monitors for the 8051 microcontroller family. MON51 may be configured for a wide variety of 8051 devices and target hardware. MON390 is designed for the Dallas Semiconductor DS80C390, DS80C400, and DS5240 microcontrollers. They communicate with the ÁVision3 Debugger using one of the PC's COM ports.
MON51 and MON390 help you easily debug your target programs in real time. You may view program symbols, debug using your source code, watch program variables, examine memory contents, and more.
The ÁVision3 Debugger is a robust, full-featured debugger that allows you to test your applications using:
- PC-based microcontroller simulation
- Target-based debugging using a monitor program
- Target-based debugging using an emulator
- Target-based debugging using an OCDS interface
- Full symbolic information
- Source-level debugging
- Simple breakpoints
- Complex, conditional breakpoints
- Dual Watchpoint windows
- Dual Memory windows
- Complete, extensible Peripheral Simulation
- C Macro Language to extend the debugger capabilities
- Performance analysis
- Code coverage analysis
ISD51 In-System Debugger
ISD51 (In-System Debugger) is a new debug monitor technology for 8051 user programs. ISD51 consists of a configurable debug module that you link to your user programs to provide support for program testing via the 8051 on-chip UART.
The software and hardware requirements of ISD51 are minimal. It can run from external or on-chip CODE space and requires no special hardware components like von Neumann-wired memory.
ISD51 works on both very small 8051 devices like the Philips LPC series and on complete systems that have access to the full CODE and XDATA address space.
C51 C Compiler
The Keil C51 C Compiler for the 8051 microcontroller is the most popular 8051 C compiler in the world. It provides more features than any other 8051 C compiler available today.
The C51 Compiler allows you to write 8051 microcontroller applications in C that have the efficiency and speed of assembly language. Language extensions in the C51 Compiler give you full access to all resources of the 8051.
C51 translates C source files into a relocatable object module. When the DEBUG control is used, the object file contains full symbolic information for debugging with the ÁVision3 Debugger or an in-circuit emulator. In addition to the object file, the C51 Compiler generates a listing file which optionally may include symbol table and cross-reference information.
- 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
- Built-in interface for the RTX51 real-time operating system
- Support for dual data pointers on Atmel, AMD, Cypress, Dallas Semiconductor, Infineon, Philips, and Triscend microcontrollers
- Support for the Philips 8xC750, 8xC751, and 8xC752 limited instruction sets
- Support for the Infineon 80C517 arithmetic unit
CX51 C Compiler
The Keil CX51 C Compiler is an ANSI Standard C Compiler for the Philips 51MX architecture. The Philips 51MX is an 8051-based microcontroller architecture that supports up to 8 MBytes of code and 8 MBytes of data.
The CX51 Compiler should only be used to generate code for 51MX derivatives. It offers the following features not found in the Keil C51 C Compiler.
- Support for all Philips 51MX devices.
- Supports linear memory models (8 MBytes code and 8 MBytes data).
- Uses run-time library designed specifically for the 51MX.
A51 Macro Assembler
The A51 Assembler is a macro assembler for the 8051 family of microcontrollers. It supports all 8051 derivatives. It translates symbolic assembly language mnemonics into relocatable object code where the utmost speed, small code size, and hardware control are critical. The macro facility speeds development and conserves maintenance time since common sequences need only be developed once. The A51 assembler supports symbolic access to all features of the 8051 architecture.
The A51 assembler translates assembler source files into a relocatable object modules. The DEBUG control adds full symbolic information to the object module and supports debugging with the ÁVision3 Debugger or an in-circuit emulator. In addition to object files, the A51 assembler generates list files which optionally may include symbol table and cross-reference information.
AX51 Macro Assembler
The Keil AX51 Macro Assembler is an enhanced 8051 assembler that provides support for 8051-based devices with additional instructions and features. The AX51 Assembler also adds numerous enhancements that are beneficial to large application development.
Following is a list of differences between the AX51 Assembler and the A51 Assembler.
- Support is included for the Dallas Contiguous Mode Instruction Set (390/5140/400)
- Support is included for the Philips 51MX Instruction Set
- Case-sensitive symbols are supported
- Memory class support has been added
- Alignment features and relocation types have been added or enhanced
- 32-bit arithmetic for expression calculations is supported
- 8051 SFRs are no longer predefined
- More words are reserved for the assembler (ECALL for example)
- OMF2 object module format is used
The ÁVision3 IDE from Keil Software combines project management, make facilities, source code editing, program debugging, and complete simulation in one powerful environment. ÁVision3 helps you get programs working faster than ever while providing an easy-to-use development platform. The editor and debugger are integrated into a single application and provide a seamless embedded project development environment. ÁVision3 features include:
- The Device Database which automatically sets the assembler, compiler, and linker options for the chip you select. This prevents you from wasting your time configuring the tools and helps you get started writing code faster.
- A robust Project Manager which lets you create several different configurations of your target from a single project file. The Keil ÁVision3 IDE allows you to create an output file for simulating, an output file for debugging with an emulator, and an output file for programming an EPROM -- all from the same Project file.
- An integrated Make facility with automatic dependency generation. You don't have to figure out which header files and include files are used by which source files. The Keil compilers and assemblers do that automatically.
- Interactive Error Correction. As your project compiles, errors and warnings appear in an output window. You may make corrections to the files in your project while ÁVision3 continues to compile in the background. Line numbers associated with each error or warning are automatically resynchronized when you make changes to the source.
BL51 Code Banking Linker/Locator
The BL51 code banking linker/locator combines OMF51 object modules and creates executable 8051 programs. The linker resolves external and public references and assigns absolute or fixed addresses to relocatable program segments.
The BL51 Linker processes object files created by the Keil C51 Compiler and A51 Assembler and the Intel PL/M-51 Compiler and ASM-51 Assembler. These object modules must adhere to the OMF51 object module specification. BL51 outputs an absolute OMF51 object module that may be loaded into practically any emulator, the Keil ÁVision3 Debugger, or the OH51 Object-HEX converter (to create an Intel HEX file).
LX51 Enhanced Linker
The LX51 linker/locator combines object modules and creates executable 8051 programs. The linker resolves external and public references and assigns absolute or fixed addresses to relocatable program segments. It processes object files created by the Keil C51 Compiler, CX51 Compiler, A51 Assembler, AX51 Assembler, and the Intel PL/M-51 Compiler and ASM-51 Assembler and generates an absolute OMF2 object module.
The LX51 Enhanced Linker offers the following features that are not available in the BL51 Code Banking Linker:
- Special ROM Handling -- The LX51 linker provides the SROM memory class that is used to handle segments or memory classes that are stored in ROM but copied to RAM for execution.
- Segment and Class Information -- The LX51 linker creates special symbols that can be used to obtain address and length information for segments or classes used in an application.
- Bank Table Optimization -- The LX51 linker allows you to specify the default code bank after reset. This optimization reduces the size of the inter-bank jump table.
- User Provided Memory Classes -- The USERCLASS directive (for the C51 and CX51 compilers) allows you to specify class names for compiler-generated segments.
- Support for XDATA Constants -- You may declare variables in the far const memory space which is located in ROM.
- Linker Code Packing -- This linker optimization reduces total program size by up to 8%.
- AJMP/ACALL Optimization -- When using this optimization, the linker rearranges program segments so that AJMP and ACALL instructions used (instead of LJMP and LCALL).
- Global Assembler Code File -- The linker can generate a program-wide mixed source/disassembly listing.
- Far Memory Support -- The LX51 linker supports up to 8 MBytes of code and 8 MBytes of data space.
- Case Sensitive Symbol Names -- Symbol names are now case-sensitive.
- Detailed Data Type Checking -- Detailed information is included in the object module for all program objects (like variables, functions, function argument lists, unions, structs, and so on). The LX51 Linker compares these between object modules and reports any mismatches. This helps you locate subtle errors in the declarations of your functions, structures, and variables.
- Support for Up To 64 Code Banks -- Code banking programs may now support up to 4 MBytes of program space.
OH51 Object-HEX Converter
The OH51 Object-HEX converter creates Intel HEX files from absolute OMF51 object modules, created by the Keil A51 assembler, BL51 code banking linker, or OC51 banked object converter.
Intel HEX files are ASCII files that contain a hexadecimal representation of your program. They easily may be loaded into a device programmer for writing EPROMs or other memory devices.
OC51 Banked Object Converter
The OC51 banked object file converter is a utility that creates an absolute object module for each code bank in a banked object module. You should not use this utility unless you have created a code banking program using the BL51 code banking linker.
When you create a code banking application, all symbolic and source-level information is maintained in the banked object module and is transferred by OC51 to each individual absolute object module for each code bank.
Once you have used OC51 to create the absolute object modules, you may use OH51 to create an Intel HEX file for each code bank.
Leadtime: Ships within 1 week
Country of Origin: USA