子程序
- 格式：ppt
- 大小：320.50 KB
- 文档页数：20
文档推荐
-
高中数学必修三(程序框图)专题页数:3
-
高考算法程序框图真题练习及答案详解页数:27
-
考试必备-高中数学专题-程序框图-含答案页数:7
-
程序框图计算训练(含答案详解)页数:9
-
专题：算法与程序框图[答案版]页数:2
-
高考数学专题突破：程序框图难题页数:29
下载文档原格式
合集下载
子程序的定义及使用
不但浪费了宝贵的时间和精力,而且也容易出错。任何数学
表达式实际上都可表示成一元、二元或多元函数关系,即 F(x1,x2,…,xn),这些函数关系如果没有对应的标准函数,则 需要用户设法定义新的函数来实现它们。
FORTRAN 90提供了语句函数定义功能来定义一些简单的 函数,用于实现有关的函数关系。用户自定义语句函数其使 用方法与标准函数相同,可以作为操作数在表达式中调用。
DB＝F(x,y,z,y) DG＝F(x,y,z,z) WRITE(*,*) DA,DB,DG
END program
9.3 外部函数子程序
无法用一条语句来定义的函数，可以用一个单独的 程序单位定义，它不属于调用函数语句所在的程序 单位，因此称之为外部函数。
是用户自定义的函数子程序。所在程序的其他程序 单位都可以调用它。
SUBROUTINE add(m,n,s) INTEGER m,n,s s=m+n m=m+1
END SUBROUTINE add
外部子例行程序,简称外部子程序，也称外部过程,是 独立的程序单元。
外部子例行程序可产生多个结果，由参数返回。 外部子例行程序定义一般格式：
<外部子例行程序定义>→
函数引用、外部函数引用以及外部函数名和子程序名等。 如果定义外部函数无形式参数,其引用形式为：F( )。 外部函数执行过程：
若实在参数为表达式,则先对表达式求值。 实在参数与相应的形式参数结合,将实参值传递给对应形参。 经过形实结合,形式参数获得了所需要的值,然后,立即执
行内部函数体。 在 执 行 函 数 体 的 过 程 中 , 若 遇 到 RETURN 语 句 或 END
F(x1,x2,x3)=3.14159*(x1+x2/60.0+x3/3600.0)/180.0 A=F(36.0,43.0,27.0) B=F(15.0,24.0,0.0) C=F(8.0,16.0,54.0) S=COS(A)**2-4*SIN(B)*TAN(C) WRITE (*,*) A,B,C,S
表达式实际上都可表示成一元、二元或多元函数关系,即 F(x1,x2,…,xn),这些函数关系如果没有对应的标准函数,则 需要用户设法定义新的函数来实现它们。
FORTRAN 90提供了语句函数定义功能来定义一些简单的 函数,用于实现有关的函数关系。用户自定义语句函数其使 用方法与标准函数相同,可以作为操作数在表达式中调用。
DB＝F(x,y,z,y) DG＝F(x,y,z,z) WRITE(*,*) DA,DB,DG
END program
9.3 外部函数子程序
无法用一条语句来定义的函数，可以用一个单独的 程序单位定义，它不属于调用函数语句所在的程序 单位，因此称之为外部函数。
是用户自定义的函数子程序。所在程序的其他程序 单位都可以调用它。
SUBROUTINE add(m,n,s) INTEGER m,n,s s=m+n m=m+1
END SUBROUTINE add
外部子例行程序,简称外部子程序，也称外部过程,是 独立的程序单元。
外部子例行程序可产生多个结果，由参数返回。 外部子例行程序定义一般格式：
<外部子例行程序定义>→
函数引用、外部函数引用以及外部函数名和子程序名等。 如果定义外部函数无形式参数,其引用形式为：F( )。 外部函数执行过程：
若实在参数为表达式,则先对表达式求值。 实在参数与相应的形式参数结合,将实参值传递给对应形参。 经过形实结合,形式参数获得了所需要的值,然后,立即执
行内部函数体。 在 执 行 函 数 体 的 过 程 中 , 若 遇 到 RETURN 语 句 或 END
F(x1,x2,x3)=3.14159*(x1+x2/60.0+x3/3600.0)/180.0 A=F(36.0,43.0,27.0) B=F(15.0,24.0,0.0) C=F(8.0,16.0,54.0) S=COS(A)**2-4*SIN(B)*TAN(C) WRITE (*,*) A,B,C,S
子程序(数铣)
2
10
50
20
30
子程序的构成
O××××；子程序号 …………； …………； …………；子程序内容 …………； M99； 返回主程序
子程序调用指令
M98 P__ __ __ __××××
调用次数
调用的 子程序号
M98 P61001； 调用1001号子程序6次 M98 P1001；
主子程序调用关系
3.2
制图 校核 审图
槽轮
材料
比例
处
其余
技术要求
.未注尺寸公差按 照 -m。 2.允许周边铣一四 方台至98x98mm， 高10mm和铣平顶面, 以方便测量。 3.送检前应去毛刺 和清理干净。 4.材料：正火 ，HB170
A
制图 校核 审图
六方
材料
比例
技术要求
.未注尺寸公差按照 -m。 2.允许周边铣一四方台 至98x98mm，高10mm和铣 平顶面,以方便测量。 3.送检前应去毛刺和清 理干净。 4.材料：正火，HB170
R 粗 加 工 刀 具 半 径 补 偿 D01
修正量
R 精加工余量
利用刀具半径补偿进行粗、精加工
1号 刀
2号 刀
Z0
图5-27 刀具长度补偿原理
H02
主轴
H01
其余
技术要求
.未注尺寸公差按照 -m。 2.允许周边铣一四方台 至98x98mm，高10mm和 铣平顶面,以方便测量。 3.送检前应去毛刺和清 理干净。 4.材料：正火，HB170
思
考:
凸台高度5→15mm，
如何实现铣削加工?
子程序调用编程举例(二)
利用子程序调用实现 分层加工: 用φ12 的立铣刀
7.子程序：过程和函数
• 过程体： 过程体：
Procedure <过程名 参数表 is 过程名>(参数表 过程名 参数表) 说明部分; 说明部分 Begin 顺序语句； 顺序语句； [return；] --与c语言不一样 ； 与 语言不一样 End procedure 过程名； 过程名；
• 过程体用于具体描述过程的功能，可放在 过程体用于具体描述过程的功能， package体中 体中 • Return语句为可选项，用于提前结束进程 语句为可选项， 语句为可选项 如果没有return，则执行完所有语句。 体。如果没有 ，则执行完所有语句。
过程调用环境的顺序与并行
• 在顺序语句中调用过程语句
– 顺序执行 – 可视为一条复合语句
• 在并行语句中调用过程语句
– 整体与其他语句并行执行 – 由in或inout类型的参数触发，执行调用 类型的参数触发， 或 类型的参数触发
过程的复用（重载） 过程的复用（重载）
• 重载：具有不同参数数目或不同数据 重载： 类型的同名过程，称重载过程。 类型的同名过程，称重载过程。
函数的调用
直接以函数名(实参表 作为表达式使用 直接以函数名 实参表)作为表达式使用 实参表 Use work.packexp.all; …. Architecture … begin out1<=max(dat1,dat2); process(dat3,dat4) begin out2<= max(dat3,dat4); end process End;
– – – – P(val1,val2,val3,val4); P(a=>val1,b => val2,c => val3,d => val4); P(val1,val2, c => open,val4); P(val1,val2, ,val4);
子程序设计实验报告
实验名称：子程序设计实验日期：2023年X月X日实验地点：XX大学计算机实验室实验目的：1. 理解子程序的概念和作用。
2. 掌握子程序的设计方法和调用方式。
3. 学会使用子程序提高程序的可读性和可维护性。
实验内容：一、实验背景子程序是程序设计中常用的一种结构，它可以将一段具有独立功能的代码封装起来，方便在其他程序中调用。
使用子程序可以提高程序的可读性、可维护性和模块化程度。
二、实验环境1. 操作系统：Windows 102. 编译器：Visual Studio 20193. 编程语言：C++三、实验步骤1. 创建一个新的C++项目，命名为“子程序设计”。
2. 在项目中创建一个头文件“Subroutine.h”，用于声明子程序。
3. 在头文件中声明两个子程序：`Add` 和 `Subtract`。
4. 在头文件中定义一个全局变量 `Result`。
5. 在源文件“Subroutine.cpp”中实现头文件中声明的子程序。
6. 在主函数中调用子程序，并输出结果。
7. 编译并运行程序，观察输出结果。
四、实验代码1. 头文件“Subroutine.h”：```cpp#ifndef SUBROUTINE_H#define SUBROUTINE_Hvoid Add(int a, int b);void Subtract(int a, int b); int Result;#endif // SUBROUTINE_H```2. 源文件“Subroutine.cpp”：```cpp#include "Subroutine.h"void Add(int a, int b) {Result = a + b;}void Subtract(int a, int b) { Result = a - b;}```3. 主函数“main.cpp”：```cpp#include <iostream>#include "Subroutine.h"int main() {int a = 10;int b = 5;Add(a, b);std::cout << "Add: " << Result << std::endl;Subtract(a, b);std::cout << "Subtract: " << Result << std::endl;return 0;}```五、实验结果与分析1. 编译并运行程序，输出结果如下：```Add: 15Subtract: 5```2. 分析：（1）在实验中，我们首先在头文件中声明了两个子程序 `Add` 和 `Subtract`，它们分别用于计算两个整数的和与差。
子程序的结构
<>
汇编语言程序设计
汇编语言程序设计
子程序的结构
子程序又称为过程或者函数，是一段能够独立的完成 某项功能的程序段。每一个子程序都是由子程序的定义 和子程序的调用构成。
1.子程序
子程序的结构包括： 子程序的定义；子程序的程序段；子程序的返回。 设计子程序，与程序的设计方法完全相同，可以采用顺 序、分支和循环结构；不同之处只是在于子程序的程序 段只有被调用时，其代码才能称为过程调用，本书称为主程序调用。 当主程序在需要调用子程序时，可以使用调用指令直接 调用已经定义的子程序，转去执行子程序的程序段，执 行完成后，由返回指令直接返回到主程序中调用指令的 下一条指令继续执行主程序。
3.子程序与循环结构的区别 两者都是重复执行一些相同的程序段，但循环结构每次 处理的数据都必须具有一定的规律，而子程序的程序段 每次处理的数据可以是任意的。可见，当需要对不同的 数据进行相同的处理时，应当采用子程序结构。
汇编语言程序设计
汇编语言程序设计
子程序的结构
子程序又称为过程或者函数，是一段能够独立的完成 某项功能的程序段。每一个子程序都是由子程序的定义 和子程序的调用构成。
1.子程序
子程序的结构包括： 子程序的定义；子程序的程序段；子程序的返回。 设计子程序，与程序的设计方法完全相同，可以采用顺 序、分支和循环结构；不同之处只是在于子程序的程序 段只有被调用时，其代码才能称为过程调用，本书称为主程序调用。 当主程序在需要调用子程序时，可以使用调用指令直接 调用已经定义的子程序，转去执行子程序的程序段，执 行完成后，由返回指令直接返回到主程序中调用指令的 下一条指令继续执行主程序。
3.子程序与循环结构的区别 两者都是重复执行一些相同的程序段，但循环结构每次 处理的数据都必须具有一定的规律，而子程序的程序段 每次处理的数据可以是任意的。可见，当需要对不同的 数据进行相同的处理时，应当采用子程序结构。
第5章4 子程序设计
X,1000H GOON: INC AX LOOP GOON RET DELAY ENDP Code ends end start
由于主程序和子程序具有相互独立性，而CPU 中的寄存器是公用的，所以它们在使用寄存器时会 发生冲突，即：如果主程序在调用子程序之前的某 一寄存器中的内容在从子程序返回后还有用，而子 程序又恰好使用了此寄存器，这样就会破坏寄存器 中原有的内容，从而造成在返回主程序时程序因数 据的丢失而出现错误。
在设计一个子程序之前，首先应该明确： 子程序的名字； 子程序的功能； 入口参数：为了运行这个子程序，主程序为它准备了哪几个 “已知条件”？这些参数存放在什么地方？ 出口参数：这个子程序的运行结果有哪些？存放在什么地方？ 影响寄存器：执行这个子程序会改变哪几个寄存器的值？ 其它需要说明的事项。
BX,OFFSET X SI, OFFSET ROOT
；初始化指针
MOV
ONE: MOV
CX, 5
AX, [BX]
；设置计数器初值
；设置入口参数 ；调用子程序
CALL SQUARE
MOV
ADD INC
[SI], AL
BX, 2 SI
；保存返回参数（平方根）
；修改指针 ；修改指针
LOOP ONE
JMP $ CODE ENDS
• • • • • • • • • • • • • • • • • •
change proc cmp ah,90 jb m1 mov al,'A' jmp exit m1: cmp ah,80 jb m2 mov al,'B' jmp exit m2: cmp ah,60 jb m3 mov al,'C' jmp exit m3: mov al,'D' exit: ret change endp code ends end start
由于主程序和子程序具有相互独立性，而CPU 中的寄存器是公用的，所以它们在使用寄存器时会 发生冲突，即：如果主程序在调用子程序之前的某 一寄存器中的内容在从子程序返回后还有用，而子 程序又恰好使用了此寄存器，这样就会破坏寄存器 中原有的内容，从而造成在返回主程序时程序因数 据的丢失而出现错误。
在设计一个子程序之前，首先应该明确： 子程序的名字； 子程序的功能； 入口参数：为了运行这个子程序，主程序为它准备了哪几个 “已知条件”？这些参数存放在什么地方？ 出口参数：这个子程序的运行结果有哪些？存放在什么地方？ 影响寄存器：执行这个子程序会改变哪几个寄存器的值？ 其它需要说明的事项。
BX,OFFSET X SI, OFFSET ROOT
；初始化指针
MOV
ONE: MOV
CX, 5
AX, [BX]
；设置计数器初值
；设置入口参数 ；调用子程序
CALL SQUARE
MOV
ADD INC
[SI], AL
BX, 2 SI
；保存返回参数（平方根）
；修改指针 ；修改指针
LOOP ONE
JMP $ CODE ENDS
• • • • • • • • • • • • • • • • • •
change proc cmp ah,90 jb m1 mov al,'A' jmp exit m1: cmp ah,80 jb m2 mov al,'B' jmp exit m2: cmp ah,60 jb m3 mov al,'C' jmp exit m3: mov al,'D' exit: ret change endp code ends end start
使用子程序的注意事项
1.编写子程序时，一般采用增量方式编程，这样可减少计算量。
2.主程序中的模态指令可被子程序中同一组的其他G 代码所更改。
如子程序用了G91代码后，再返回主程序时将继续以G91方式进行，故应特别注意代码的转换，否则可能产生位置错误。
3.调用程序时使用刀补。
最好不要在刀具补偿状态下的主程序中调用子程序，换句话来说，刀补的建立和取消应在子程序进行。
如果必须在主程序中建立，则应在主程序中消除。
绝不能在主程序中建立，在子程序取消，也不能在子程序建立，在主程序中消除，否则极易出错。
4.子程序不能单独运行。
第13课(子程序(过程与函数))
变量的作用域
写出下列程序的运行结果: 例 写出下列程序的运行结果
var x,y:integer; 运行结果如下: 运行结果如下 procedure a; *1*2 var x:integer; #2# begin #2# x:=2; writeln('#',x,'#'); writeln('#',y,'#'); * * *1 * * * 2 end;{of a} begin{main program} x:=1;y:=2; writeln('*',x,'*',y); , a; writeln('***',x,'***',y); end.
函数定义的一般格式: 函数定义的一般格式 function <函数名 (<形式参数表 函数名> 形式参数表 形式参数表>):<类型 {函数首部 类型>; 函数首部 函数首部} 函数名 类型
函数调用方式与标准函数的调用方式相同. 函数调用方式与标准函数的调用方式相同. 函数调用的一般格式: 函数调用的一般格式: 函数名> <函数名> S:=area(b1,b5,b6)+area(b2,b6,b7)+area(b3,b4,b7); 或 实在参数 实在参数 实在参数 函数名>(实在参数表) >(实在参数表 <函数名>1 2
运行结果: 运行结果: 1 2 2 1
函数和过程的区别
过程和函数都为子程序,但也有区别: 过程和函数都为子程序,但也有区别:
1,标识符不同.函数的标识符为FUNCTION,过程为:PROCEDURE. ,标识符不同.函数的标识符为 ,过程为: . 2,函数中一般不用变量形参,用函数名直接返回函数值;而过程如有返 ,函数中一般不用变量形参,用函数名直接返回函数值; 回值,则必须用变量形参返回. 回值,则必须用变量形参返回. 3,过程无类型,不能给过程名赋值;函数有类型, 3,过程无类型,不能给过程名赋值;函数有类型,最终要将函数值传送 给函数名. 给函数名 4,函数在定义时一定要进行函数的类型说明,过程则不进行过程的类型 ,函数在定义时一定要进行函数的类型说明, 说明. 说明. 5,调用方式不同.函数的调用出现在表达式中,过程调用由独立的过程 ,调用方式不同.函数的调用出现在表达式中, 调用语句来完成. 调用语句来完成. 6,过程一般会被设计成求若干个运算结果,完成一系列的数据处理, ,过程一般会被设计成求若干个运算结果,完成一系列的数据处理, 或与计算无关的各种操作;而函数往往只为了求得一个函数值. 或与计算无关的各种操作;而函数往往只为了求得一个函数值.
子程序的调用和返回指令
1、子程序的调用和返回指令子程序的调用和返回是一对互逆操作，也是一种特殊的转移操作。
一方面，之所以说是转移，是因为当调用一个子程序时，程序的执行顺序被改变，CPU将转而执行子程序中的指令序列，在这方面，调用子程序的操作含有转移指令的功能，子程序的返回指令的转移特性与此类似；另一方面，转移指令是一种“一去不复返”的操作，而当子程序完后，还要求CPU能转而执行调用指令之下的指令，它是一种“有去有回”的操作。
为了满足子程序调用和返回操作的特殊性，在指令系统中设置了相应的特定指令。
1、1调用指令(CALL)调用子程序指令的格式如下：CALL 子程序名/Reg/Mem子程序的调用指令分为近(near)调用和远(far)调用。
如果被调用子程序的属性是近的，那么，CALL指令将产生一个近调用，它把该指令之后地址的偏移量(用一个字来表示的)压栈，把被调用子程序入口地址的偏移量送给指令指针寄存器IP即可实现执行程序的转移如果被调用子程序的属性是远的，那么，CALL指令将产生一个远调用。
这时，调用指令不仅要把该指令之后地址的偏移量压进栈，而且也要把段寄存器CS的值压进栈。
在此之后，再把被调用子程序入口地址的偏移量和段值分别送给IP和CS，这样完成了子程序的远调用操作00405600 call 0040689500405604 ......子程序调用指令本身的执行不影响任何标志位，但子程序体中指令的执行会改变标志位，所以，如果希望子程序的执行不能改变调用指令前后的标志位，那么，就要在子程序的开始处保护标志位，在子程序的返回前恢复标志位。
例如：CALL DISPLAY;DISPLAY是子程序名CALL BX;BX的内容是子程序的偏移量CALL WORD1;WORD1是内存字变量，其值是子程序的偏移量CALL DWORD1;DWORD1是双字变量，其值是子程序的偏移量和段值CALL word ptr [BX];BX所指内存字单元的值是子程序的偏移量CALL dword ptr [BX];BX所指内存双字单元的值是子程序的偏移量和段值1、2返回指令(RET)当子程序执行完时，需要返回到调用它的程序之中。
子程序
子程序是一个为实现某个功能的独立程序。 其特点是：
它总被其它程序调用而一般不能单独执行。通
常把调用它的程序称为主程序，被主程序调用 的程序称为子程序。当然，其概念也是相对的， 即子程序也可以调用其他子程序。
主程序与子程序的调用关系
主程序Main.prg 子程序Sub.prg
…… Do Sub …… Return
2．带参数过程的调用
若要给过程中形式参数传递数据，必须在主程序中将实际参数包 含在过程的调用命令中，带有参数的过程调用的命令格式为： 格式： DO 〈过程名〉 WITH 〈实际参数表〉 功能： 将〈实际参数表〉中的内容传递给指定〈过程名〉相对应的形式 参数表，然后执行该过程。 说明： Ⅰ 〈实际参数表〉中的参数必须与PARAMETER语句中定义的 形式参数变量表的数量、类型与次序上完全一致。 Ⅱ 〈实际参数表〉中的参数可以是常量、变量和表达式，各个参 数间用“,”分隔。
&& 定义函数名AREA && 定义函数的形参 R && 返回函数的值
习题：写一个求任意数阶层的函 数，在主程序中调用该函数求任 意三个数的阶层之和 （S=A!+B!+C！）
10.5 参数的传递
无论是过程、还是自定义函数，参数传递都是一个 非常重要的概念。 传递参数： Do <子程序名/过程名> with <实际参数表> 说明：写在主程序中。 接受参数： Parameters <形式参数表> 说明：写在过程（或者函数等）中。
例1：编写一个求1到N的累加和的过程，并在过程中输出和。 clear input "input n:" to x do leijia with x Return procedure leijia parameters n sum=0 for i=1 to n sum=sum+i endfor ?sum return
子程序的调用
mov ax,data mov ds,ax call nearp lea ax,nearp call ax call nproc lea bx,nproc call word ptr [bx]
call farp call fproc lea bx,fproc
Nearp proc near
…… ret Nearp endp Code1 ends end main code2 segment
3)在调用时,NEAR 和FAR 可以强制改变 CALL FAR PTR NEARPROC CALL NEAR PTR FARPROC
子过程的调用与返回指令
子过程的调用是个”有去有回”的过程,子程序执行
完后必须返回CALL指令的下一条指令处,因此必须对
CALL指令的下条指令的地址进行保存.保存地址的操作 是通过堆栈来完成.不是采用PUSH \POP指令来实现,而
通过存储器来传递参数
当调用程序和子程序处于同一文件中，可以直接访问 块内的变量或数据。 举例3：编写程序从键盘上输入一个字符串，存于变量为INPUT中， 要求以回车键作为输入过程的结束，字符结尾部分添加0。 （1） 分析： 子程序getstring直接从键盘输入字符串，入口参数：无。出 口参数：字符串变量INPUT 变量INPUT 属于通过存储器传递参数，调用程序和子程序处 于同一文件在数据段定义变量属于局部变量
Findmax proc
mov ax,[si] Lp1: cmp ax,[si+2] jg next xchg ax,[si+2] next: add si,2 loop lp1 ret findmax endp Code ends
end main
参数的传递
第六章 子程序和宏程序
二、宏程序
在程序中可使用变量、并通过变量赋值、运算及 运用其它能够控制程序执行顺序的控制指令，从而 使程序具有特定功能的程序被称之宏程序。宏程序 的作用与子程序相类似，它具有某种通用功能，由 主程序的专业语句调用，执行完宏程序后再返回主 程序。 宏程序由三部分组成。1、宏程序名：字母O后 接5位自然数；2、宏程序体；3、宏程序结束指令 M99。宏程序名和结束指令与子程序相同，但调用 指令不相同。
G01 Z#8 F#5； ； 以给定的进给速度钻孔 G00 Z#6； ； 从孔底返回 #10=#10+1； ； END 1 GOTO 910； ； N900 #3000=140（DATA LACK）； （ ）； N910 M99； ；
实例
采用O9100宏程序，加工分布在中心（52，78）的4个均布孔，分 布直径为40mm，起始角度为30°，各孔等分角度为90 °，钻孔时快速 接近平面为5mm，孔深度为20mm，进给速度为100mm/min，刀具快速 返回平面为50mm。其程序如下： O100 G90 G54 ; G00 S540 M3 Z100; G43 H01; G65 P9100 X52.0 Y78.0 I40.0 B90.0 D4.0 A30.0 C5.0 E-20.0 J100. K50.0; G00 X0 Y0; G49 Z0; M30;
子程序1 钻孔） 子程序1（钻孔）
O1000 N0001 G00 G90 Z5.0； 快速接近工件 N0005 G01 Z-35.F100.； 钻孔 N0010 G00 Z5.0； 快速返回参考平面 N0015 M99； 子程序结束
子程序2 子程序2（从左至右钻4个孔）
O1001 N0001 N0005 N0010 N0015 N0020 N0025 N0030 N0035 P1000； M98 P1000； X30.； G91 X30.； P1000； M98 P1000； X30.； G91 X30.； P1000； M98 P1000； X30.； G91 X30.； P1000； M98 P1000； M99； M99； 调用子程序1 调用子程序1，钻1号孔，返回参考平面 号孔， 移动到2 移动到2号孔 调用子程序1 号孔， 调用子程序1，钻2号孔，返回参考平面 移动到3 移动到3号孔 调用子程序1 号孔， 调用子程序1，钻3号孔，返回参考平面 移动到4 移动到4号孔 调用子程序1 号孔， 调用子程序1，钻4号孔，返回参考平面 子程序结束
宏与子程序的区别
宏与子程序的区别宏和子程序都是为了简化源程序的编写，提高程序的可维护性，但是它们二者之间存在着以下本质的区别：1 、在源程序中，通过书写宏名来引用宏，而子程序是通过CALL 指令来调用；2 、汇编程序对宏通过宏扩展来加入其定义体，宏引用多少次，就相应扩展多少次，所以，引用宏不会缩短目标程序；而子程序代码在目标程序中只出现一次，调用子程序是执行同一程序段，因此，目标程序也得到相应的简化；3 、宏引用时，参数是通过“实参”替换“形参”的方式来实现传递的，参数形式灵活多样，而子程序调用时，参数是通过寄存器、堆栈或约定存储单元进行传递的；4 、宏引用语句扩展后，目标程序中就不再有宏引用语句，运行时，不会有额外的时间开销，而子程序的调用在目标程序中仍存在，子程序的调用和返回均需要时间。
总之，当程序片段不长，速度是关键因素时，可采用宏来简化源程序，但当程序片段较长，存储空间是关键因素时，可采用子程序的方法来简化源程序和目标程序。
处理的时间不同．宏调用是在源程序被汇编程序处理的；而子程序调用是在程序执行期间由CP 直接执行的．处理的方式不同．两者都必须先定义后使用，但宏调用是用宏体替换宏调用伪指令，实参代替形参，源程序被翻译成目标代码后宏定义随着消失；而子程序则没有这样的替换操作，是以CALL 指令将控制权由调用者转给子程序并执行．参数处理不同．宏调用是以实参代替形参，参数的形式不受限制，可以是任何合法的字符；子程序的参数需要寄存器或存储单元进行传递，而且需要附加的指令实现参数传递．执行速度不同．子程序调用时需要执行CALL 指令和RET 指令，还要执行实现参数传递的附加指令，因而会比宏展开后的代码多而执行速度稍慢．占用的存储器空间大小不同．宏指令在每次调用时都要展开，把宏体中的程序段复制一遍，因而用宏指令编写的程序在目标代码中会重复出现相同或相似的程序段，占用内存空间较大；而子程序是由CALL 指令调用的，无论调多少次，子程序的目标代码只在程序中出现一次，目标代码相对较短．宏与子程序具有各自的特点，程序员应该根据具体问题选择使用那种方法通常，当程序段较短或要求较快执行时，应选用宏；当程序段较长或为减小目标代码时，要选用子程序比较结论。
汇编语言之子程序
汇编语言之子程序汇编语言是一种底层编程语言，是计算机指令的集合表示形式。
在汇编语言中，子程序是一段独立的、可重复使用的代码片段，可以在程序中被多次调用。
子程序可以帮助我们实现代码的模块化，提高代码的可读性和可维护性。
本文将介绍如何在汇编语言中使用子程序以及其工作原理。
一、子程序的定义和使用在汇编语言中，子程序由一系列指令组成，这些指令可以完成特定的功能。
子程序可以通过call指令被调用，执行完子程序后会返回到调用子程序的指令处，继续执行程序的下一条指令。
在使用子程序前，我们需要先定义子程序。
定义子程序的语法如下：```subroutine_name:; 子程序代码ret```其中，subroutine_name是子程序的名称，可以根据实际需求自定义。
ret指令用于返回到调用子程序的指令处，继续执行程序的下一条指令。
调用子程序的语法如下：```call subroutine_name```其中，subroutine_name是要调用的子程序的名称。
二、传递参数和返回值子程序可以接收参数，并且可以有返回值。
在调用子程序时，可以通过寄存器或栈来传递参数。
在子程序内部，可以通过相应的寄存器或栈地址来获取参数的值。
例如，我们定义一个计算两个数之和的子程序add：```add:mov ax, [bp+4] ; 获取第一个参数的值add ax, [bp+6] ; 获取第二个参数的值ret```在主程序中调用add子程序：```mov ax, 5 ; 第一个参数mov bx, 10 ; 第二个参数call add ; 调用add子程序; 此时ax寄存器中的值为15，即5+10的结果```在子程序add中，我们通过寻址方式获取传递的参数，并将计算结果存入ax寄存器中，供主程序使用。
三、保存和恢复寄存器在汇编语言中，调用子程序时需要保存和恢复寄存器的值，以保证程序的正确执行。
在调用子程序前，我们可以使用push指令将需要保存的寄存器值压栈，然后在子程序的开头使用相应的pop指令将值弹出并恢复。
单片机常用子程序
// P3.0~P3.3，第1～4列
// P3.4~P3.7，第1～4行
// 0 1 2 3
// 4 5 6 7
// 8 9 10 11
// 12 13 14 15
//****************************************************
void delay(unsigned int t)
while(P3!=0xf0);//等待按键弹出
//beep();
return(key);
}
void main()
{
while(1)
{
unsigned char key;
key=ScanKey44();
switch(key)
{
case 0x11:key=0; break; //0
case 0x24:key=6; break; //6
case 0x28:key=7; break; //7
case 0x41:key=8; break; //8
case 0x42:key=9; break; //9
case 0x44:key=10; break; //10
key=P3&0x3c;
while((P3&0x3c)!=0x3c); //等待弹出
//beep();
return(key);
}
#define S1 0x0e
#define S2 0x0d
#define S3 0x0b
#define S4 0x07
//4个简单按键扫描子程序
case 0x12:key=1; break; //1
// P3.4~P3.7，第1～4行
// 0 1 2 3
// 4 5 6 7
// 8 9 10 11
// 12 13 14 15
//****************************************************
void delay(unsigned int t)
while(P3!=0xf0);//等待按键弹出
//beep();
return(key);
}
void main()
{
while(1)
{
unsigned char key;
key=ScanKey44();
switch(key)
{
case 0x11:key=0; break; //0
case 0x24:key=6; break; //6
case 0x28:key=7; break; //7
case 0x41:key=8; break; //8
case 0x42:key=9; break; //9
case 0x44:key=10; break; //10
key=P3&0x3c;
while((P3&0x3c)!=0x3c); //等待弹出
//beep();
return(key);
}
#define S1 0x0e
#define S2 0x0d
#define S3 0x0b
#define S4 0x07
//4个简单按键扫描子程序
case 0x12:key=1; break; //1
子程序的调用
主程序流程图
开始
调用子程序DECBIN,从键盘 接受一个十进制并转化为对应的二进制 调用子程序CRLF实现回车换行 调用子程序BINHEX,把二进制数转换成 16进制并显示 调用子程序CRLF实现回车换行 Y 是否退出 N 接收下一次键盘输入 END
decbin PROC NEAR push ax push cx mov bx,0 mov si,0 Newchar: mov ah,1 int 21h cmp al,’*’ je ext1 sub al,30h jl ext2 cmp al,9 jg ext2 cbw xchg ax,bx mov cx,10 mul cx xchg ax,bx add ax,bx jmp newchar
子程序的定义
3.注意问题
1)过程体内必须有一条RET指令被执行 proc1 proc mov ax,0 proc1 endp proc2 proc mov bx,-1 ret proc endp
子程序的定义
2)调用程序和过程在同一程序段时,属性选择NEAR,当调 用程序和过程不在同一程序段时,应选择FAR 3)在调用时,NEAR 和FAR 可以强制改变 CALL FAR PTR NEARPROC CALL NEAR PTR FARPROC
参数的传递
1 参数传递： 当子程序被调用时，一般需要向子程序传递若干参数， 由子程序来对这些参数完成特定功能处理；当子程序 处理后，需要向调用它的主程序传递结果。这种主程 序和子程序之间的信息的传递称为参数的传递。
参数的传递
2 参数传递方法： 寄存器传递参数 存储器传递参数 地址表传递变量地址 堆栈传递参数
子过程的调用与返回指令
4.子程序调用方式举例
分析下面程序段,说明各种调用子程序的方法和寻址方式: data segment nproc dw nearp fproc dd farp data ends code1 segment assume cs:code1,cs:data Main proc far
汇编语言——子程序
M
【解】 （1）当计算机把CALL subp对应的机器指令取到CPU中 时，IP的值已经是CALL的下一行的MOV指令所在的偏移地 址5678H，此时还未进栈，栈的情况如图6.3(a)所示。 （2）由于子程序subp是NEAR类型，按照CALL指令功能 的第一种情况执行CALL指令，把IP的值入栈，并把IP的值改 为subp子程序的入口地址1234H，此时堆栈的情况如图6.3(b) 所示。 （3）执行完CALL指令 IP的值已经变成1234H，CS没变， CPU按新的IP值，在CS段下取出一条指令，即INC AL指令。
【例6.2】分析下面的程序段的执行过程，以及在执行过 程中堆栈及指令指针IP的变化情况，并假设在执行CALL指令 前，SP的值是0FEH。 subp PROC INC NEAR AL ;假设本指令所在的偏移地址是1234H
M
RET subp ENDP
M
CALL MOV 5678H subp AX,BX ;假设本指令所在的偏移地址是
M
子程序2 ENDP
M
子程序n PROC NEAR
M
子程序n ENDP 入口标号: M 段名 ENDS
从入口标号起的程序段是主程序。RET指令必须出现在子 程序中，而CALL指令可以出现在代码段的任何地方。主程序 可以调用子程序，一个子程序可以调用另一个子程序，还可 以调用它自身，并且在书写次序上没有“先定义后调用”的 限制。 源程序中的指令段在经过汇编程序的翻译后，所有伪指 令都不存在了。作为CALL指令的操作数，“子程序名”部分 会翻译成子程序第一条指令的逻辑地址。当计算机在执行 CALL 指令时，CS和IP已经是下一条指令的逻辑地址。CALL 指令具有保存当前IP或者CS和IP并修改它们的值的能力，因 此CALL执行完后，会按照新的CS及IP，转去执行子程序的第 一条指令，并依次执行后续指令，完成子程序的功能，直至 遇到RET指令。RET指令的执行效果是从栈中取出由CALL保 存的数据，恢复在执行CALL指令时的IP或者CS与IP值，从而 回到CALL指令的下一行继续执行。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数控车削技术
成刀具折断；刀具埋在深孔中切削无法观察，加工质 量较难控制等。
一般深孔加工工艺上采取的措施是：采用具有适合 深孔加工的几何形状和几何角度的刀具及解决冷却排 屑问题。
数控车削技术
2、 薄壁零件数控加工难点及采取措施
难点：工件易产生变形。
主要措施有：
(1)夹紧力尽可能径向截面上分布均匀； (2)夹紧力的位置宜选在工件刚性较强的部位； (3)采取轴向夹紧工件方法； (4)在工件上制出加强刚性的辅助凸边。
④、工艺系统刚性差，因受孔径尺寸限制，孔的长 径比较大，刀杆细而长，刚性差，易产生震动，钻孔 易走偏，因而支承导向极为重要。
数控车削技术
（3）、深孔加工主要解决问题
冷却，润滑，排屑，合理导向。
综上可以看出，深孔加工的特点及工艺上需采取 的措施如下：
深孔加工的特点：随着加工孔长度的增加，使孔 加工所用刀具的刚性减弱。另一方面，孔的精度和表 面粗糙度要求的提高，又使刀具形状趋于复杂 削液注入困难，切屑不易排出，经常出现切屑堵塞， 拉毛孔壁并使刀具磨损加剧，极易造
c 二级嵌套
O0001 : : M98P400; : : M99
d 三级嵌套
O0001 : : : : : M99
e 四级嵌套
数控车削技术
4、子程序编程举例
x
o
z
数控车削技术
例如：加工零件如上图所示，已知毛坯直径 Ф32mm，长度为50mm，一号刀为外圆车刀， 二号刀为切断刀，其宽度为2mm，其加工程序如
下主：程序
O0010 N10 G50 X150.0 Z100.0 N20 G50 S1800 N30 G00 G96 S150 T0101 N40 M03 N50 M08 N60 X35.0 Z0
数控车削技术
N70 G98 G01 X0.F100(车右端面） N80 G00 Z2.0 N90 X30.0 N100 G01 Z-40.0F100(车外圆） N110 G00 X150.0 Z100.0 T0202 N120 X32.0 Z0 N130 M98 P0031008(切三槽） N140 G00 W-100 N150 G01 X0 F60(切断） N160 G04 X2.0(暂停2S) N170 G00 X150.Z100.0 N180 M30
数控车削技术
格式二：M98 P××××××××
例3 M98 P50010； 例4 M98 P0500；
说明：
（1）地址P后面的八位数中，前四位表示调用次数， 后四位表示子程序号， （2）调用次数前的0可以省略不写，但子程序号前 的0不可省略。
数控车削技术
3、子程序的嵌套
为了进一步简化加工程序，可以允许子程序在调用 另一个子程序，这一功能称为子程序的嵌套。
说明：
（1）子程序一般不可以作为独立的加工程序使用。只能 通过主程序进行调用，实现加工中的局部动作。
（2）子程序结束后，能自动返回到调用它的主程序中。
数控车削技术
2、子程序的调用格式
格式一：M98 P××××L××××;
例1：M98 P100 L5 ； 例2：M98 P100；
说明：
（1）P后面的四位数字为子程序号，L后面的数字表示 重复调用次数，且P、L后面的四 位数中前面的0可以以 省略不写。 （2）如只调用一次，则L及后面的数字可省略。
当主程序调用子程序时，该子程序被认为是一级子 程序，FANUC O系统中的子程序允许4级嵌套。 FANUC 0T/18T系统中，只能有2级嵌套。
如下图所示：
数控车削技术
O0001 : : M98P100; : : M30
a 主程序
O0001 : : M98P200; : : M99
b 一级嵌套
O0001 : : M98P300; : : M99
数控车削技术
1、深孔数控加工的难点及采取措施
（1）、深孔概念
孔加工分为浅孔加工和深孔加工两类，也包括介于两者之间 的中孔加工，一般规定孔深L与孔径d0之比大于5，即L/d0>5 的孔称为深孔； L/d0≤5的孔称为浅孔。
（2）深孔加工特点
深孔加工时处于封闭或半封闭状态下进行的，股具有以下特 点：
①不能直接观察到刀具的切削情况，目前只能凭经验，通过 声音，看切削，观察机床负荷及压力表，触摸震动等外观现象 来判断切削过程是否正常。
数控车削技术
第十一讲 子程序
(M98/M99)
数控车削技术
任务描述
x
o
z
数控车削技术
任务目标：
掌握子程序的含义及用法。
任务难点重点： M98/M99指令的含义 子程序的嵌套使用
数控车削技术
一、数控车床子程序编程 二、典型零件数控加工简析
数控车削技术
一、子程序
1、子程序的概念
一组程序段在一个程序中多次出现，或者在几个程序 中都要使用它，我们将这样一组程序段单独加以命名， 做成固定的程序，这组程序段称为子程序。
数控车削技术
3、车削细长轴时工件产生弯曲的原因及消除方法
（1）、坯料自重或本自弯曲，应对毛坯进行较直和热处 理。 （2）、工件装夹不良，尾座顶尖与工件中心孔顶得过紧。 应适当顶尖与工件的松紧程度。 （3）、刀具几何参数和切削用量选择不当。根据实际情 况合理选择参数。 （4）、工件切削时产生热变形。加注切削液。 （5）、刀尖与跟刀架支承块间距离过大。加工中间距应 保持在2mm以内。
数控车削技术
子程序
O1008 N300 G00 W-10.0 N310 G98 G01 U-12.0 F60 N320 G04 X1.0 N330 G00 U12.0 N340 M99
数控车削技术
二、典型零件数控加工简析
主要内容： 1、深孔数控加工的难点及采取措施 2、 薄壁零件数控加工难点及放错措施 3、车削细长轴时工件产生弯曲的原因及消除方法
数控车削技术
②、切削热不易传散，一般切削过程中80%的切削 热被切削带走，而深孔钻削只有40%，刀具占切削热 的比例较大，扩散迟，易过热。必须采用强制有效的 冷却方式。
③、切削不易排出。由于孔深，切削经过路线长， 容易发生阻塞，造成刀具损坏，因此，切屑的长短和 形状要加以控制，并要进行强制性排屑。