第十五章结构体、共用体及枚举

第十五章结构体、共用体及枚举15.1 结构体的概念15.2 结构体类型变量的定义15.3 关于结构体类型有几点需要注意的地方15.4 结构体变量的应用15.5 结构体变量的初始化15.6 结构体数组15.7 指向结构体类型的指针15.8 用指向结构变量的指针引用结构体成员15.9 指向结构体数组的指针15.10 将结构体变量和指向结构体的指针作函数参数 15.11 共用体的概念15.12 共用体类型变量的定义15.13 共用体变量的引用15.14 枚举类型15.15 计时器设计（待显时间存放于结构体变量中）实验15.16 跑表设计（计时时间存放于结构体变量中）实验15.17 计时器设计（计时时间存放于共用体变量中）实验15.18 枚举类型实验

15.1 结构体的概念结构体是一种构造类型的数据，它是结构体是一种构造类型的数据，它是将若干个不同类型的数据变量有序地组合在将若干个不同类型的数据变量有序地组合在一起而形成的一种数据的集合体。组成该集一起而形成的一种数据的集合体。组成该集合体的各个数据变量称为结构成员，整个集合体的各个数据变量称为结构成员，整个集合体使用一个单独的结构变量名。一般来说合体使用一个单独的结构变量名。一般来说结构中的各个变量之间是存在某些关系的，结构中的各个变量之间是存在某些关系的，如时间数据中的时、分、秒，日期数据中的如时间数据中的时、分、秒，日期数据中的年、月、日等。由于结构是将一组相关联的年、月、日等。由于结构是将一组相关联的数据变量作为一个整体来进行处理，因此在数据变量作为一个整体来进行处理，因此在程序中使用结构将有利于对一些复杂而又具程序中使用结构将有利于对一些复杂而又具有内在联系的数据进行有效的管理。有内在联系的数据进行有效的管理。

15.2 结构体类型变量的定义 1.1. 先定义结构体类型再定义变先定义结构体类型再定义变 ff 名名定义结构体类型的一般格式为定义结构体类型的一般格式为 :: Struct Struct 结构体名结构体名 {{ 成员表列成员表列 };}; 其中，“结构体名”用作结构体类型的其中，“结构体名”用作结构体类型的标志。“成员表列”为该结构体中的各个成标志。“成员表列”为该结构体中的各个成员，由于结构体可以由不同类型的数据组成，员，由于结构体可以由不同类型的数据组成，因此对结构体中的各个成员都要进行类型说因此对结构体中的各个成员都要进行类型说明。明。

例如例如 :: 定义一个日期结构体类型定义一个日期结构体类型 datedate ，它可由，它可由 66 个个结构体成员结构体成员 year, month, day, hour, min,secyear, month, day, hour, min,sec 组成组成 Struct data Struct data {{ int year;int year; char month;char month; char day;char day; Char hOllr;Char hOllr; char min;char min; char sec:char sec: };};

15.2 结构体类型变量的定义

定义好一个结构体类型之后，就可定义好一个结构体类型之后，就可以用它来定义结构体变量。一般格式为以用它来定义结构体变量。一般格式为 :: structstruct 结构体名结构体变量名结构体名结构体变量名 11 ，结构体，结构体变量名，变量名， ···· 结构体变量名结构体变量名 n;n; 例如例如 :: 可以用结构体可以用结构体 datedate 来定义两来定义两个结构体变量个结构体变量 timeltimel 和和 time2 .time2 . struct date timel.time2struct date timel.time2 这样结构体变量这样结构体变量 timeltimel 和和 time2time2 都都具有具有 struct datestruct date 类型的结构，即它们都类型的结构，即它们都是是 11 个整型数据和个整型数据和 55 个字符型数据所组成。个字符型数据所组成。


一般格式为一般格式为 :: structstruct 结构体名结构体名 {{ 成员表列成员表列 }} 结构体变量名结构体变量名 11 ，结构体变量名，结构体变量名 2, …2, … 结构体变量名结构体变量名 n;n; 例如例如 :: 对上述日期结构体变量也可按以下格式定义对上述日期结构体变量也可按以下格式定义 :: struct datestruct date {{ int year;int year; char month:char month: charchar

charday;hourchar minchar sec}timel,time2


15.2 结构体类型变量的定义一般格式为一般格式为 :: structstruct {{ 成员表列成员表列 }} 结构体变量名结构体变量名 11 ，结构体变量名，结构体变量名 22 ，……结构体变量名，……结构体变量名 n;n; 第第 33 种方法与第种方法与第 22 种方法十分相似，所不同的是第种方法十分相似，所不同的是第 33种方法中省略了结构体名，这种方法一般只用于定义几个种方法中省略了结构体名，这种方法一般只用于定义几个确定的结构变量的场合。例如确定的结构变量的场合。例如 :: 如果只需要定义如果只需要定义 timeltimel 和和 titi

me2me2 而不打算再定义任何别的结构变量，则可省略掉结构而不打算再定义任何别的结构变量，则可省略掉结构体名“体名“ date"date" 。不过为了便于记忆和以备将来进一步定义。不过为了便于记忆和以备将来进一步定义其他结构体变量的需要，一般还是不要省略结构名为好。其他结构体变量的需要，一般还是不要省略结构名为好。

15.3 结构体类型需要注意的地方如下 ① ① 结构体类‘型与结构体变量是两个不同的结构体类‘型与结构体变量是两个不同的概念概念 ·· 定义一个结构体类型时只给出了该结构定义一个结构体类型时只给出了该结构体的组织形式，并没有给出具体的组织成员。体的组织形式，并没有给出具体的组织成员。因此，结构体名不占用任何存储空间，也不能因此，结构体名不占用任何存储空间，也不能对一个结构体名进行赋值、存取和运算。对一个结构体名进行赋值、存取和运算。而结构体变量则是一个结构体中的具体而结构体变量则是一个结构体中的具体对象，编译器会给具体的结构体变量名分配确对象，编译器会给具体的结构体变量名分配确定的存储空间，因此可以对结构体变量名进行定的存储空间，因此可以对结构体变量名进行赋值、存取和运算。赋值、存取和运算。

② ② 将一个变量定义为标准类型与定义为结构体将一个变量定义为标准类型与定义为结构体类型有所不同。前者只需要用类型说明符指出类型有所不同。前者只需要用类型说明符指出变量的类型即可，如变量的类型即可，如 int X;int X; 。后者不仅要求用。后者不仅要求用structstruct 指出该变量为结构体类型，而且还要求指出该变量为结构体类型，而且还要求指出该变量是哪种特定的结构类型，即要指出指出该变量是哪种特定的结构类型，即要指出它所属的特定结构类型的名字。如上面的它所属的特定结构类型的名字。如上面的 datedate就是这种特定的结构体类型就是这种特定的结构体类型 (( 日期结构体类型日期结构体类型 ))的名字。的名字。

③ ③ 一个结构体中的成员还可以是另外一个结一个结构体中的成员还可以是另外一个结构体类型的变量，即可以形成结构体的嵌套。构体类型的变量，即可以形成结构体的嵌套。

15.3 结构体类型需要注意的地方如下

15.4 结构体变量的引用定义了一个结构体变量之后，就可以对定义了一个结构体变量之后，就可以对它进行引用，即可以进行赋值、存取和运算。它进行引用，即可以进行赋值、存取和运算。一般情况下，结构体变量的引用是通过对其成一般情况下，结构体变量的引用是通过对其成员的引用来实现的。员的引用来实现的。 ①① 引用结构体变量中的成员，一般格式为引用结构体变量中的成员，一般格式为 :: 结构体变量名结构体变量名 .. 成员名成员名其中“其中“ .”.” 是存取成员的运算符。是存取成员的运算符。例如例如 :timl. year=2006;:timl. year=2006; 表示将整数表示将整数 20062006赋给赋给 timeltimel 变量中的成员变量中的成员 yearyear

② ② 如果一个结构体变量中的成员又是另外一个如果一个结构体变量中的成员又是另外一个结构体变量，即出现结构体的嵌套时，则需要结构体变量，即出现结构体的嵌套时，则需要采用若干个成员运算符，一级一级地找到最低采用若干个成员运算符，一级一级地找到最低一级的成员，而且只能对这个最低级的结构元一级的成员，而且只能对这个最低级的结构元素进行存取访问。素进行存取访问。 ③ ③ 对结构体变量中的各个成员可以像普通变量对结构体变量中的各个成员可以像普通变量一样进行赋值、存取和运算。一样进行赋值、存取和运算。例如例如 :time2. secC++;:time2. secC++; ④ ④ 可以在程序中直接引用结构体变量和结构可以在程序中直接引用结构体变量和结构体成员的地址。结构体变量的地址通常用作函体成员的地址。结构体变量的地址通常用作函数参数，用来传递结构体的地址。数参数，用来传递结构体的地址。

15.4 结构体变量的引用

15.5 结构体变量的初始化和其他类型的变量一样，对结构体类型的变量也和其他类型的变量一样，对结构体类型的变量也可以在定义时赋初值进行初始化。例如可以在定义时赋初值进行初始化。例如 :: struct datestruct date {{ int year;int year; char month;char month; char day;char day; char hour;char hour; char min;char min; char sec;char sec; }timel={2006,7,23,1r,4,20);}timel={2006,7,23,1r,4,20);

15.6 结构体数组一个结构体变量可以存放一组数据一个结构体变量可以存放一组数据 (( 如一个时间点如一个时间点

timeltimel 的数据的数据 )) ，在实际使用中，结构体变量往往不止一，在实际使用中，结构体变量往往不止一个个 (( 如我们要对如我们要对 2020 个时间点的数扭进行处理）这时可将个时间点的数扭进行处理）这时可将多个相同的结构体组成一个数组，这就是结构体数组。多个相同的结构体组成一个数组，这就是结构体数组。结构体数组的定义方法与结构体变量完全一致。例如结构体数组的定义方法与结构体变量完全一致。例如 :: struct datestruct date {{ int year;int year; char month;char month; char day;char day;

char hour;char min;char sec;};struct date time[20];

15.7 指向结构体类型数据的指针一个结构体变量的指针，就是该变量在一个结构体变量的指针，就是该变量在内存中的首地址。可以设一个指针变量，将它内存中的首地址。可以设一个指针变量，将它指向一个结构体变量，则该指针变量的值是它指向一个结构体变量，则该指针变量的值是它所指向的结构体变量的起始地址。所指向的结构体变量的起始地址。定义指向结构体变量的指针的一般格式为定义指向结构体变量的指针的一般格式为 :: Struct Struct 结构体类型名结构体类型名 ** 指针变量名指针变量名 ;; 或或 StructStruct {{ 成员表列成员表列 } *} * 指针变量名指针变量名 ;; 与一般指针相同，对于指向结构体变量与一般指针相同，对于指向结构体变量的指针也必须先赋值后引用。的指针也必须先赋值后引用。

15.8 用指向结构体变量的指针引用结构体成员

通过指针来引用结构体成员的一般格式为通过指针来引用结构体成员的一般格式为 :: 指针变量名一指针变量名一 >> 结构体成员结构体成员例如Struct data{int year;char month;char day:char hour;

char min;char sec;};struct date timel;struct data *p;P=&timel;P->year=2006;

指向结构体数组的指针指向结构体数组的指针已经了解了一个指针变量可以指向数组。已经了解了一个指针变量可以指向数组。同样，指针变量也可以指向结构体数组。同样，指针变量也可以指向结构体数组。指向结构体数组的指针变量的一般格式为指向结构体数组的指针变量的一般格式为 :: Struct Struct 结构体数组名结构体数组名 ** 指针变量名；指针变量名；

由于采用的是华业艾丛宾只需要传递一个地址值 · 与前者相比大大节省了存储空间，同时还加快了程序的执行速度。其缺点是在调用函数时对指针所作的任何变动都会影响到原来的结构体变量。

15.915.9 指向结构体数组的指针指向结构体数组的指针

15.10 将结构体变量和指向结构体的指针作函数参数结构体既可作为函数的参数，也可作为函结构体既可作为函数的参数，也可作为函数的返回值。当结构体被用作函数的参数时，其数的返回值。当结构体被用作函数的参数时，其用法与普通变量作为实际参数传递一样，属于用法与普通变量作为实际参数传递一样，属于“传值”方式。“传值”方式。但当一个结构体较大时，若将该结涵补海但当一个结构体较大时，若将该结涵补海满亥耐寥数，由于参数传递采用值传递方式，需满亥耐寥数，由于参数传递采用值传递方式，需要较大的存储空间要较大的存储空间 ((堆栈堆栈 )) 来将所有的成员压栈来将所有的成员压栈和出栈，影响程序的执行速度。这时可以用指向和出栈，影响程序的执行速度。这时可以用指向结构体的指针来作为函数的参数，此时参数的传结构体的指针来作为函数的参数，此时参数的传递是按地址传递方式进行的。递是按地址传递方式进行的。

15.11 共用体的概念结构体变量占用的内存空间大小是其结构体变量占用的内存空间大小是其各成员所占长度的总和，如同一时刻只存各成员所占长度的总和，如同一时刻只存放其中的一个成员数据，对内存空间是很放其中的一个成员数据，对内存空间是很大的浪费。共用体也是大的浪费。共用体也是 CC 语言中一种构造语言中一种构造类型的数据结构，它所占内存空间的长度类型的数据结构，它所占内存空间的长度是其中最长的成员长度。各个成员的数据是其中最长的成员长度。各个成员的数据类型及长度虽然可能都不同，但都从同一类型及长度虽然可能都不同，但都从同一个地址开始存放，，即采用了所谓的“覆个地址开始存放，，即采用了所谓的“覆盖技术”。这种技术可使不同的变量分时，盖技术”。这种技术可使不同的变量分时，使用同一个内存空间，有效提高了内存的使用同一个内存空间，有效提高了内存的利用效率。利用效率。

15.12 共用体类型变量的定义共用体类型变量的定义方式与结构体类型变量的定共用体类型变量的定义方式与结构体类型变量的定义相似，也有义相似，也有 33 种方法。种方法。先定义共用体类型再定义变量名先定义共用体类型再定义变量名定义共用体类型的一般格式为定义共用体类型的一般格式为 :: unionunion共用体名共用体名 {{ 成员表列成员表列 };}; 定义好一个共用体类型之后，就可以用它来定义共定义好一个共用体类型之后，就可以用它来定义共用体变量。一般格式为用体变量。一般格式为 :: Union Union 共用体名共用体变量名共用体名共用体变量名 11 ，共用体变量名，共用体变量名

22 ，……共用体变量名，……共用体变量名 n;n;

在定义共用体类型的同时定义共用体变量名在定义共用体类型的同时定义共用体变量名一般格式为一般格式为 :: Union Union 共用体名共用体名｛｛成员表列成员表列 }}共用体变量名共用体变量名 11 ，共用体变量名，共用体变量名 22 ，， ·…·…共用体变量名共用体变量名 n;n; 直接定义共用体变量直接定义共用体变量一般格式为一般格式为 :: UnionUnion ｛｛成员表列成员表列 }}共用体变量名共用体变量名 11 ，共用体变量名，共用体变量名 2 2 ，， ...…...… 共用体变量名共用体变量名 n;n;

15.12 共用体类型变量的定义

共用体类型与结构体类型的定义方法十分相似，共用体类型与结构体类型的定义方法十分相似，只是将关键字只是将关键字 structstruct改成了改成了 uniorunior但是在内存的分但是在内存的分配上两者却有着本质的区别。结构体变量所占用的内配上两者却有着本质的区别。结构体变量所占用的内存长度是其中各个元所占用内存长度的总和，而共用存长度是其中各个元所占用内存长度的总和，而共用体变量所占用的内存长度是其中最长的成员长度。体变量所占用的内存长度是其中最长的成员长度。 Struct exmp1Struct exmp1 {{ Int a;Int a; Char b;Char b; };}; Struct exmpl x;Struct exmpl x;


结构体变量结构体变量 xx 所占用的内存长度是成员所占用的内存长度是成员 a,ba,b长度长度的总和，的总和， aa 占用占用 22 字节，字节， bb 占用占用 11 字节，总共占用字节，总共占用 33字节。再如字节。再如 :: union exmp2union exmp2 {{ int a;int a; char b;char b; };}; union exmp2 y;union exmp2 y; 共用体变量共用体变量 YY 所占用的内存长度是最长的成员所占用的内存长度是最长的成员 aa的长度，的长度， aa 占用占用 22 字节，故总共占用字节，故总共占用 22 字节。字节。


15.4 枚举类型如果一个变量只有几种可能的值，那如果一个变量只有几种可能的值，那么可以定义为枚举类型。所谓“枚举”是将么可以定义为枚举类型。所谓“枚举”是将变量的值变量的值一一列举出来，变量的取值只限干列出的范一一列举出来，变量的取值只限干列出的范围。围。一个完整的枚举定义说明语句的一般格式为一个完整的枚举定义说明语句的一般格式为 :: Enum Enum 枚举名枚举名 {{枚举值列表枚举值列表 }} 变量列表变量列表 ;; 定义和说明也可以分成两句完成定义和说明也可以分成两句完成 :: Enum Enum 枚举名枚举名 {{枚举值列表枚举值列表 };}; Enum Enum 枚举名变量列表枚举名变量列表 ; ;

15.15 计时器设计 ( 待显时间存放于结构体变璧中 ) 实验 #include<REG51.H>#include<REG51.H> #define uint unsigned int#define uint unsigned int #define uchar unsigned char#define uchar unsigned char //***********************************//*********************************** uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0

x66,x66, 0x6d,0x7d,0x07,0x7f,0x6f};0x6d,0x7d,0x07,0x7f,0x6f}; uchar code ACT[8]={0xfe,0xfd,0xfb,0xf7,uchar code ACT[8]={0xfe,0xfd,0xfb,0xf7, 0xef,0xdf,0xbf,0x7f};0xef,0xdf,0xbf,0x7f}; uint hour;uint hour; uchar min,sec,cnt;uchar min,sec,cnt; void delay(uint k);void delay(uint k);

struct deda{uint dhour;uchar dmin;uchar dsec;};struct deda dis_buff;

void initial(void){TMOD=0x01;TH0=-(50000/256);

TL0=-(50000%256);ET0=1;TR0=1;EA=1;

}

15.15 计时器设计 ( 待显时间存放于结构体变璧中 ) 实验

void time0(void) interrupt 1{TH0=-(50000/256);TL0=-(50000%256);cnt++;if(cnt>=20){sec++;cnt=0;}if(sec>=60){min++;sec=0;}if(min>=60){hour++;min=0;}if(hour>9999){hour=0;}dis_buff.dhour=hour;dis_buff.dmin=min;dis_buff.dsec=sec;}


void main(void)void main(void) {{ initial();initial(); for(;;)for(;;) {{ P0=SEG7[dis_buff.dhour%10];P0=SEG7[dis_buff.dhour%10]; P2=ACT[4];P2=ACT[4]; delay(1);delay(1); P0=SEG7[(dis_buff.dhour%100)/10];P0=SEG7[(dis_buff.dhour%100)/10]; P2=ACT[5];P2=ACT[5]; delay(1);delay(1); P0=SEG7[(dis_buff.dhour%1000)/100];P0=SEG7[(dis_buff.dhour%1000)/100]; P2=ACT[6];P2=ACT[6]; delay(1);delay(1); P0=SEG7[dis_buff.dhour/1000];P0=SEG7[dis_buff.dhour/1000]; P2=ACT[7];P2=ACT[7]; delay(1);delay(1);


P0=SEG7[dis_buff.dsec%10];P2=ACT[0];delay(1);P0=SEG7[dis_buff.dsec/10];P2=ACT[1];delay(1);P0=SEG7[dis_buff.dmin%10];P2=ACT[2];delay(1);P0=SEG7[dis_buff.dmin/10];P2=ACT[3];delay(1);}

}

void delay(uint k)

{uint data i,j;for(i=0;i<k;i++){for(j=0;j<121;j++){;}}}

15.16 跑表设计 ( 计时时间存放于结构体变量中 ) 实验

15.16 跑表设计 ( 计时时间存放于结构体变量中 ) 实验 #include <REG51.H>#include <REG51.H> #define uint unsigned int#define uint unsigned int #define uchar unsigned char#define uchar unsigned char uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66, 0x6d,0x7d,0x07,0x7f,0x6f};0x6d,0x7d,0x07,0x7f,0x6f}; uchar code ACT[8]={0xfe,0xfd,0xfb,0xf7,uchar code ACT[8]={0xfe,0xfd,0xfb,0xf7, 0xef,0xdf,0xbf,0x7f};0xef,0xdf,0xbf,0x7f}; uchar status;uchar status; sbit OUT=P1^0;sbit OUT=P1^0; void delay(uint k);void delay(uint k);

struct time{uchar sec;uchar msec;};struct time run_time,set_time;struct time *pt1,*pt2;

void initial(void){TMOD=0x11;TH0=-(10000/256);TL0=-(10000%256);TH1=-(1000/256);TL1=-(1000%256);ET0=1;ET1=1;TR1=1;

EA=1;}

void time0(void) interrupt 1void time0(void) interrupt 1{{TH0=-(10000/256);TH0=-(10000/256);


TL0=-(10000%256);TL0=-(10000%256); run_time.msec++;run_time.msec++; if(run_time.msec>99)if(run_time.msec>99) {run_time.sec++;run_time.msec=0;}{run_time.sec++;run_time.msec=0;} if(run_time.sec>99)if(run_time.sec>99) {run_time.msec=0;run_time.sec=0;}{run_time.msec=0;run_time.sec=0;} if((pt2->msec>0)||(pt2->sec>0))if((pt2->msec>0)||(pt2->sec>0)) {{ if((pt1->msec==pt2->msec)&&(pt1->sec==if((pt1->msec==pt2->msec)&&(pt1->sec==

pt2->sec))pt2->sec)) {TR0=0;OUT=0;}{TR0=0;OUT=0;} }} }}void display(uchar cnt)void display(uchar cnt)


{{ switch(cnt)switch(cnt) {{ case0 :P0=SEG7[run_time.msec%10];case0 :P0=SEG7[run_time.msec%10]; P2=ACT[0];break;P2=ACT[0];break; case 1:P0=SEG7[run_time.msec/10];case 1:P0=SEG7[run_time.msec/10]; P2=ACT[1];break;P2=ACT[1];break; case 2:P0=SEG7[run_time.sec%10];case 2:P0=SEG7[run_time.sec%10]; P2=ACT[2];break;P2=ACT[2];break; case 3:P0=SEG7[run_time.sec/10];case 3:P0=SEG7[run_time.sec/10]; P2=ACT[3];break;P2=ACT[3];break;


case 4:P0=SEG7[set_time.msec%10];case 4:P0=SEG7[set_time.msec%10]; P2=ACT[4];break;P2=ACT[4];break; case 5:P0=SEG7[set_time.msec/10];case 5:P0=SEG7[set_time.msec/10]; P2=ACT[5];break;P2=ACT[5];break; case 6:P0=SEG7[set_time.sec%10];case 6:P0=SEG7[set_time.sec%10]; P2=ACT[6];break;P2=ACT[6];break; case 7:P0=SEG7[set_time.sec/10];case 7:P0=SEG7[set_time.sec/10]; P2=ACT[7];break;P2=ACT[7];break; default:break;default:break; }} }}


void set_ms_display(uchar cnt)void set_ms_display(uchar cnt) {{ switch(cnt)switch(cnt) {{ case 0:P0=SEG7[run_time.msec%10];case 0:P0=SEG7[run_time.msec%10]; P2=ACT[0];break;P2=ACT[0];break; case 1:P0=SEG7[run_time.msec/10];case 1:P0=SEG7[run_time.msec/10]; P2=ACT[1];break;P2=ACT[1];break; case 2:P0=SEG7[run_time.sec%10];case 2:P0=SEG7[run_time.sec%10]; P2=ACT[2];break;P2=ACT[2];break; case 3:P0=SEG7[run_time.sec/10];case 3:P0=SEG7[run_time.sec/10]; P2=ACT[3];break;P2=ACT[3];break; case 4:P0=SEG7[set_time.msec%10]case 4:P0=SEG7[set_time.msec%10] |0x80;P2=ACT[4];break;|0x80;P2=ACT[4];break;


case 5:P0=SEG7[set_time.msec/10]case 5:P0=SEG7[set_time.msec/10] |0x80;P2=ACT[5];break;|0x80;P2=ACT[5];break; case 6:P0=SEG7[set_time.sec%10];case 6:P0=SEG7[set_time.sec%10]; P2=ACT[6];break;P2=ACT[6];break; case 7:P0=SEG7[set_time.sec/10];case 7:P0=SEG7[set_time.sec/10]; P2=ACT[7];break;P2=ACT[7];break; default:break;default:break; }} }}


void set_s_display(uchar cnt)void set_s_display(uchar cnt) {{ switch(cnt)switch(cnt) {{ case 0:P0=SEG7[run_time.msec%10];case 0:P0=SEG7[run_time.msec%10]; P2=ACT[0];break;P2=ACT[0];break; case 1:P0=SEG7[run_time.msec/10];case 1:P0=SEG7[run_time.msec/10]; P2=ACT[1];break;P2=ACT[1];break; case 2:P0=SEG7[run_time.sec%10];case 2:P0=SEG7[run_time.sec%10]; P2=ACT[2];break;P2=ACT[2];break; case 3:P0=SEG7[run_time.sec/10];case 3:P0=SEG7[run_time.sec/10]; P2=ACT[3];break;P2=ACT[3];break;


case4:P0=SEG7[run_time.msec%10];case4:P0=SEG7[run_time.msec%10]; P2=ACT[4];break;P2=ACT[4];break; case 5:P0=SEG7[set_time.msec/10];case 5:P0=SEG7[set_time.msec/10]; P2=ACT[5];break;P2=ACT[5];break; case 6:P0=SEG7[set_time.sec%10]|0x80;case 6:P0=SEG7[set_time.sec%10]|0x80; P2=ACT[6];break;P2=ACT[6];break; case 7:P0=SEG7[set_time.sec/10]|0x80;case 7:P0=SEG7[set_time.sec/10]|0x80; P2=ACT[7];break;P2=ACT[7];break; default:break;default:break; }} }}


void time1(void) interrupt 3{static uchar cnt;TH1=-(1000/256);TL1=-(1000%256);cnt++;if(cnt>7)cnt=0;

switch(status){case 5: display(cnt);break;case 0: display(cnt);break;case 1: set_ms_display(cnt);break;case 2: set_s_display(cnt);break;default:break;}

}


void key_s1(void){

P3=0xff; if(P3==0xfb) { switch(status) { case 1:if(set_time.msec==99)set_time.msec=99;

else set_time.msec++;break; case 2:if(set_time.sec==99)set_time.sec=99;

else set_time.sec++;break; default :break; } }

}


void key_s2(void){

P3=0xff; if(P3==0xf7) { switch(status) { case 1:if(set_time.msec==0)set_time.msec=0;

else set_time.msec--;break; case 2:if(set_time.sec==0)set_time.sec=0;

else set_time.sec--;break; default :break; } }

}


void key_s4(void){

P3=0xff;if(P3==0xdf){status++;}if(status==3)status=1;if(status==6){run_time.msec=0;run_time.sec=0;status=0;}

}void key_s3(void){

P3=0xff;if(P3==0xef){status=5;TR0=1;}

}


void main(void)void main(void) {{ pt1=&run_time;pt2=&set_time;pt1=&run_time;pt2=&set_time; initial();initial(); for(;;)for(;;) {{ key_s1();key_s1(); key_s2();key_s2(); key_s3();key_s3(); key_s4();key_s4(); delay(300);delay(300); }} }}

void delay(uint k)

{uint data i,j;

for(i=0;i<k;i++){for(j=0;j<121;j++){;}}}


15.17 计时器设计 ( 计时时间存放于共用体变量中 ) 实验 #include<REG51.H>#include<REG51.H> #define uint unsigned int#define uint unsigned int #define uchar unsigned char#define uchar unsigned char uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66, 0x6d,0x7d,0x07,0x7f,0x6f};0x6d,0x7d,0x07,0x7f,0x6f}; uchar code ACT[4]={0xfe,0xfd,0xfb,0xf7};uchar code ACT[4]={0xfe,0xfd,0xfb,0xf7}; uint hour;uint hour; uchar min,sec,cnt;uchar min,sec,cnt; uchar status;uchar status; void delay(uint k);void delay(uint k);

union dedaunion deda {{ uint dhour;uint dhour; uchar dmin;uchar dmin; uchar dsec;uchar dsec; };}; union deda dis_buff;union deda dis_buff; void time0(void) interrupt 1void time0(void) interrupt 1

void initial(void) { TMOD=0x01; TH0=-(50000/256); TL0=-(50000%256);

ET0=1; TR0=1; EA=1;

}

15.17 计时器设计 ( 计时时间存放于共用体变量中 ) 实验

{{ TH0=-(50000/256);TH0=-(50000/256); TL0=-(50000%256);TL0=-(50000%256); cnt++;cnt++; if(cnt>=20){sec++;cnt=0;}if(cnt>=20){sec++;cnt=0;} if(sec>=60)if(sec>=60) {min++;sec=0;status++;}{min++;sec=0;status++;} if(min>=60){hour++;min=0;}if(min>=60){hour++;min=0;} if(hour>9999){hour=0;}if(hour>9999){hour=0;} if(status>2){status=0;}if(status>2){status=0;}

switch(status){

case 0:dis_buff.dhour=hour;break;case 1:dis_buff.dmin=min;break;case 2:dis_buff.dsec=sec;break;

default:break;}

}


void main(void)void main(void) {{ initial();initial(); for(;;)for(;;) {{ switch(status)switch(status) {{ case 0:{P0=SEG7[dis_buff.dhour%10];case 0:{P0=SEG7[dis_buff.dhour%10]; P2=ACT[0];delay(1);P2=ACT[0];delay(1); P0=SEG7[(dis_buff.dhour%100)/10];P0=SEG7[(dis_buff.dhour%100)/10]; P2=ACT[1];delay(1);P2=ACT[1];delay(1);


15.17 计时器设计 ( 计时时间存放于共用体变量中 ) 实验 P0=SEG7[(dis_buff.dhour%1000)/100];P0=SEG7[(dis_buff.dhour%1000)/100]; P2=ACT[2];delay(1);P2=ACT[2];delay(1);

P0=SEG7[dis_buff.dhour/1000];P0=SEG7[dis_buff.dhour/1000];

P2=ACT[3];delay(1);}break;P2=ACT[3];delay(1);}break; case 1:{P0=SEG7[dis_buff.dmin%10];case 1:{P0=SEG7[dis_buff.dmin%10]; P2=ACT[2];delay(1);P2=ACT[2];delay(1); P0=SEG7[dis_buff.dmin/10];P0=SEG7[dis_buff.dmin/10];

P2=ACT[3];delay(1);}break;P2=ACT[3];delay(1);}break; case 2:{P0=SEG7[dis_buff.dsec%10];case 2:{P0=SEG7[dis_buff.dsec%10]; P2=ACT[0];delay(1);P2=ACT[0];delay(1); P0=SEG7[dis_buff.dsec/10];P0=SEG7[dis_buff.dsec/10]; P2=ACT[1];delay(1);}break;P2=ACT[1];delay(1);}break; default:break;default:break; }} }} }}


P2=ACT[1];delay(1);}break;P2=ACT[1];delay(1);}break; default:break;default:break; }} }} }} void delay(uint k)void delay(uint k) {{ uint data i,j;uint data i,j; for(i=0;i<k;i++){for(i=0;i<k;i++){ for(j=0;j<121;j++)for(j=0;j<121;j++) {;}}{;}} }}


15.18 枚举类型实验 #include<REG51.H>#include<REG51.H> #define uint unsigned int#define uint unsigned int #define uchar unsigned char#define uchar unsigned char uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66, 0x6d,0x7d,0x07,0x7f,0x6f};0x6d,0x7d,0x07,0x7f,0x6f}; uchar code ACT[4]={0xfe,0xfd,0xfb,0xf7};uchar code ACT[4]={0xfe,0xfd,0xfb,0xf7}; void delay(uint k);void delay(uint k); enum week_day{mon=1,tue,wed,thu,fri,sat,sun};enum week_day{mon=1,tue,wed,thu,fri,sat,sun}; enum week_day day;enum week_day day;

15.18 枚举类型实验 case 0xef:day=thu;break;case 0xef:day=thu;break; case 0xeb:day=fri;break;case 0xeb:day=fri;break; case 0xe7:day=sat;break;case 0xe7:day=sat;break; case 0xe3:day=sun;break;case 0xe3:day=sun;break; default:break;default:break; }} }} }} void key_scan(void)void key_scan(void)

{{ uchar temp;uchar temp; P3=0xff;P3=0xff; temp=P3;temp=P3; if(temp!=0xff)if(temp!=0xff) {{ switch(temp)switch(temp) {{ case 0xfb:day=mon;break;case 0xfb:day=mon;break; case 0xf7:day=tue;break;case 0xf7:day=tue;break; case 0xf3:day=wed;break;case 0xf3:day=wed;break;

15.18 枚举类型实验

void main(void) {

for(;;) { key_scan(); P0=SEG7[day];

P2=ACT[0]; delay(300); }

}

void delay(uint k) {uint data i,j; for(i=0;i<k;i++){ for(j=0;j<121;j++) {;}}}

15.18 枚举类型实验

第十五章 结构体、共用体及枚举

Documents

第十五章结构体、共用体及枚举