Intel PL/M-51开发者指南：DOS系统软件开发工具

需积分: 9 138 浏览量更新于2024-08-02 收藏 484KB PDF 举报

"plm51e说明.pdf" 是一份关于 Intel 的 PL/M-51 开发工具的用户指南，适用于 DOS 系统。这份文档详细介绍了如何使用 Intel 的软件开发工具进行编程和应用开发。正文： PL/M-51 是 Intel 为 DOS 系统设计的一种编程语言，它是一种面向过程的、结构化的编程语言，主要用于微处理器控制和嵌入式系统开发。此用户指南是学习 PL/M-51 的关键资源，尽管它是全英文的，但其详尽的说明可以帮助开发者深入了解该语言的特性和使用方法。 Intel Software Development Tools 提供了一系列的工具，包括编译器、链接器、调试器等，帮助程序员将 PL/M-51 代码转换成可在 Intel 微处理器上执行的目标代码。这些工具对于优化代码性能、调试错误以及管理项目至关重要。这份文档中可能涵盖的内容可能包括： 1. **PL/M-51 语法**：介绍 PL/M-51 语言的基本结构，如变量声明、流程控制语句（如 if-else，循环）、函数和子程序定义等。 2. **数据类型和存储管理**：讨论 PL/M-51 支持的各种数据类型，以及内存分配和管理策略。 3. **输入/输出(I/O)操作**：讲解如何与硬件设备交互，包括文件操作和系统调用。 4. **编译器使用**：指导如何使用 Intel 提供的 PL/M-51 编译器进行源代码编译，包括编译选项和错误处理。 5. **链接器和库**：解释如何将编译后的对象文件链接成可执行文件，以及如何利用预编译的库函数。 6. **调试技巧**：提供使用 Intel 调试工具来查找和修复代码错误的方法。 7. **DOS 系统接口**：描述如何在 PL/M-51 程序中调用 DOS 系统服务，实现系统级别的功能。 8. **示例和实践**：包含多个示例程序，帮助读者更好地理解和应用所学知识。请注意，Intel 在文档中声明他们保留随时更改规格而不另行通知的权利，并且不对材料的任何错误或遗漏承担责任。此外，他们不承诺更新文档或保持信息的最新性。这意味着在实际开发过程中，开发者可能需要参考其他来源以获取最新的技术信息。最后，Intel 对其软件产品拥有版权，并保留所有权利。使用、复制或披露该软件须遵守相关的版权法律。这表明，虽然可以使用这些工具和文档进行学习，但在商业应用中必须遵守相应的授权协议。

Block Nesting and Scope of Variables: An Introduction

Some blocks contain entire other blocks, as shown in the following examples.

Example 1

Start: DO;

DECLARE (A,B,C,D,E,F,G,H,L) BYTE;

A = 17;

C = B * D;

middle : DO;

DECLARE (J,K) Byte;

E = F + G;

H = J + K + A;

END middle;

Last: L = H + C;

END start ;

Example 2

Start: DO;

DECLARE (A,B,C,D,E,F,G,L) BYTE;

A = 17;

C = B * D;

Middle : DO;

DECLARE (H,J,K,L) Byte;

E = F + G;

H = J + K + A;

END middle;

Last: L = H + C; /* This is an error since H is

undeclared at outer level */

END start ;

(As shown in examples 1 and 2, multiple names of the same type can be declared in one statement;

consequently, all the names within the parentheses are of the same type.)

The block called MIDDLE is completely contained inside the block labeled START; MIDDLE is said to be

nested within the START block.

The START block is called an outer block. The phrase outer level is used to refer to statements that are in

START but not in MIDDLE. For example, the statements beginning with A = , C = , and B = are all in at

the outer level in the blocks shown in examples 1 and 2.

PL/M-51 permits each block to be independent of other blocks in that any names declared at an outer level

can be redeclared, with new meanings and values, inside a nested block. If names declared at an Outer level

are not redeclared, they keep their original locations and present contents.

Thus, A will still be 17 inside MIDDLE unless you add a new declaration to make it have a new, local

meaning there. Variables declared inside a nested block have only that local meaning while statements in

that block are being executed. The variables lose their local meaning as soon as execution passes to

statements outside that block.

Therefore, if H is only declared inside MIDDLE, as it is in Example 2, its value will be unknown in the

statement labeled “last:” the statement will be invalid and the compiler will say so. If H is also declared in

START, the value used in last will be the outer level meaning, unrelated to the one created in MIDDLE

because that H is unique. They will only be the same if their sole declaration is in START and not in

MIDDLE, as in Example 1.

The effect of these rules is that, when writing a block and declaring objects solely for use inside that block,

you need not worry about whether the same identifier has already been used in another block. Even if the

same name is used elsewhere, it refers to a different object. This subject is dealt with in detail in Chapter 9.

The notion of nested blocks, inner and outer levels, is central to successful PL/M-51 programming. For

example, the modules of a program must conform to the rule that only one module may have executable

statements at the outer-most level. That module is called the main module (or sometimes, the main

program). The Outer-most level of all other modules must only contain procedure definition blocks and

other declarations, as discussed in the sections that follow.

Most of the rules discussed in this book, including those just covered, relate to creating and preserving

unambiguous meanings, addresses, and values for each name you use. This uniqueness must be true in

every block and in communicating values between blocks.

1.5 Executable Statements

The following is a list of all PL/M-51 executable statements and the chapters in which they are discussed:

Assignment Statement Chapter 5

GOTO Statement Chapter 7

IF Statement Chapter 7

Simple DO Statement Chapter 7

Iterative DO Statement Chapter7

DO WHILE Statement Chapter 7

DO CASE Statement Chapter 7

END Statement Chapter 7

Null Statement Chapter 7

CALL Statement Chapter 10

RETURN Statement Chapter 10

ENABLE and DISABLE Chapter 10

The following sections, which give simple descriptions of some of the executable statements, should help

make you more familiar with PL/M-51 and should aid you when you encounter the full descriptions found

in later chapters.

Assignment Statement

The assignment statement has already been introduced. It is fundamental to PL/M-51 programming.

Although its form is quite simple, the expression in an assignment statement may be quite complex and

result in a considerable amount of computation, as will be seen in Chapter 5

A simple DO block begins with a simple DO statement and (like all DO blocks) may be used wherever a

single statement can be used. The following is an example of a simple DO block used in place of a single

statement in the THEN part of an IF - -statement:

IF TMP > = 4 THEN DO;

INCR = INCR + 2;

COUNT = COUNT + INCR;

END;

ELSE

COUNT = 0;

This example allows two or more executable statements to be executed if the condition is true.

An iterative DO statement introduces an iterative DO block and causes the executable statements within the

block to be executed repeatedly. The following is an example of an iterative DO statement

DO J = 0 TO 9;

VECTOR(J) = 0;

END;

where

J is a previously declared BYTE or WORD variable (which are discussed in detail

in Chapters 3, 4.and 5).

VECTOR Must be a previously declared array having at least 10 elements.

The assignment statement is executed 10 times, with values of J starting at 0 and increasing by 1 each time

around until all of the integers 0-9 have been used. Since J is used as a subscript for specifying which

element of VECTOR is referenced in the assignment statement, this iterative DO block assigns the value 0

to all elements of VECTOR from element 0 through element 9.

The DO WHILE statement contains a condition (like the condition in the IF part of an IF statement), and

causes the executable statements in the block to be executed repeatedly as long as the condition is true.

In the following example. a DO WHILE block is used to step through the elements of an array (TABLE)

until an element is found that is greater than the value of a scalar variable called LEVEL.

I = 0;

DO WHILE TABLE(I) < = LEVEL;

I = I + 1;

END;

TABLE is a previously declared array, and LEVEL and I are previously declared variables. I is first

assigned a value of 0, then is used as a subscript for TABLE. Because I is incremented in each execution of

the DO WHILE block, a different element of TABLE is compared with LEVEL each time the DO WHILE

statement is executed. When an element is found that is greater than LEVEL, the condition in the DO

WHILE statement is no longer true, the block is not repeated again, and control passes to the next statement

after the END statement. At this point, the value of I is the subscript of the first element of TABLE that was

not greater than LEVEL.

The DO CASE block, which is introduced by a DO CASE statement, uses the value of the given

expression. to select a statement to be executed. In the following example, assume that the expression TST

-l in the DO CASE statement can have any value from 0 to 3.

DO CASE TST-1;

RED = 0;

BLUE = 0;

GREEN = 0;

GREY = 0;

END;

If the value of the expression is 0, only the first assignment statement will be executed, and the value 0 will

be assigned to RED. If the value of the expression is 1, only the second assignment statement will be

executed, and the value 0 will be assigned to BLUE. Expression values of 2 or 3 will cause GREEN or

GREY, respectively, to be assigned the value 0.

1.6 Built-In Procedures

PL/M-51 has many built-in procedures. These procedures provide such functions as shifts and rotations,

data type conversions, and test-and-set. The built-in procedures are described in Chapter 11.

1.7 Expressions

As already noted, a PL/M-51 expression is made up of operands and operators, and resembles a

conventional algebraic expression.

Operands include numeric constants (such as 378 or 105) and variables (as well as other operands,

discussed in Chapters 4 and 5). The operators include + and - for addition and subtraction, * and / for

multiplication and division, and MOD for modulo arithmetic.

As in an algebraic expression, elements of a PL/M-51 expression may be grouped with parentheses.

1.8 The Program Development Process

The PL/M-51 compiler and run-time libraries are part of an integrated set of tools that make up the total

MCS-51 development solution for your microcomputer system.

The steps in the software development processes are as follows:

1. Define the problem completely.

2. Outline the proposed solution in terms of hardware plus software. Once this step is done, you may

begin designing your hardware.

3. Design the software for your system. This important step consists of several sub steps, including

breaking down the task into modules, choosing the programming language, and selecting the

algorithms to be used.

剩余155页未读，继续阅读

zhabin030524

粉丝: 0
资源: 2

Intel PL/M-51开发者指南：DOS系统软件开发工具

Agile-PLM系统简介.pdf

2022年中国PLM行业研究短报告.pdf

PLM软件架构.pdf

PLM入门知识.pdf

K3PLM销售培训.pdf

XX集团PLM需求分析.pdf

欧派家居PLM项目案例.pdf

汽车整车行业PLM解决方案.pdf

07_金蝶PLM解决方案.pdf

电动车行业PLM解决方案.pdf

最新资源