• 基于89C51单片机C语言程序花样流水
  • 花样灯由8个发光二极管构成。正常情况下,花样灯正反向循环流水点亮,控制按键SW按下时,花样灯中的发光发光二极管交替点亮;当SW断开后,花样灯恢复至正常状态。
  • C51单片机学习笔记(二)——花样流水的实现 文章目录C51单片机学习笔记(二)——花样流水的实现1.单片机引脚、晶振、复位的作用2.流水原理图3.单片机的周期4.延时函数的编写5.使用“位操作”控制流水 1.单片机...

    C51单片机学习笔记(二)——花样流水灯的实现

    1.单片机引脚、晶振、复位的作用

    在这里插入图片描述

    • 复位电路:,复位是单片机的初始化操作。单片机启动时都需要先付薇,其作用是“清零”,也就是CPU和其他部件处于一个确定的初始状态,并从这个初始状态开始。
    • 复位实质上是单片机的复位脚保持很短时间的高电平,按键复位就是通过按键接高电平(按一下的时间已经足够)
    • 时钟电路(晶振):产生时间信号,使单片机按照一定的时间规律进行指令,晶振频率越高,时钟信号的周期就小,单片机运行也就越快。

    在这里插入图片描述

    • 32个I/O口

    • P1.0 ~ P1.7 对应1 ~ 8 号引脚

    • P2.0 ~ P2.7 对应21 ~ 28 号引脚

    • P3.0 ~ P3.7 对应10 ~ 17 号引脚

    • P0.0 ~ P0.7 对应39 ~ 32 号引脚
      其中,P3口除作标准I/O口外,还可以将每一位用于第二功能:
      在这里插入图片描述
      其他引脚功能:
      在这里插入图片描述

    2.流水灯原理图

    在这里插入图片描述

    • D1~D8为发光二极管(LED),由于LED工作时能承受的电流很小,所以后面接在PR1上,PR1是一个排阻,电阻的大小一般为100Ω左右,以防止电流过大击穿二极管,P20-P27是接单片机的P2.0-P2.7的引脚,Vcc接高电平,所以电流从右向左流,要想LED导通,仅需引脚处为低电平,两端形成电位差,LED被点亮
    • 所以通过编程控制P2口的8个引脚,使他们周期性的输出高电平、低电平并延时,即可使LED闪烁,构成流水灯。

    3.单片机的周期

    • 时钟周期:

    也称振荡周期,是时钟频率的倒数,就看晶振是多少HZ的,若是12MHZ的,时钟周期就是1/12微秒,他是单片机中最小的时间单位,在一个时钟周期内单片机仅能完成一个最基本的动作。

    • 机器周期:

    是单片机的基本操作周期,为时钟周期的12倍,在一个机器周期内可以完成一个取指令的动作。

    • 指令周期:

    指单片机完成一条指令所需的时间,一般为4个机器周期。

    4.延时函数的编写

    void delay()
    {
    	unsigned int x,y;       //定义无符号的int型x,y
    	for(x = 1000;x>0;x--)
    		for(y=110;y>0;y--);
    	
    }
    
    • 每执行一次x-1,y就要从110逐步-1,直到减小到0,x共要自减1000次,总耗时约为1秒(这个时间会有误差,如果要精确延时,后面讲到中断再说明)
    • 如果一个程序里需要不同的延时时间,就需要用带参数的延时函数
    void delay(unsigned int z)
    {
    	unsigned int x,y;       //定义无符号的int型x,y
    	for(x = z;x>0;x--)
    		for(y=110;y>0;y--);
    	
    }
    

    5.使用“位操作”控制流水灯

    • 编程思路:“位操作”就是控制单独的一个I/O口,使该引脚输出高电平或低电平,来驱动与该引脚相连的元器件发生相应的动作。
    #include<reg52.h>
    sbit led0 = P2^0;  // sbit是定义位的关键字,一个引脚就是一位,P2^0代表P2.0引脚,以此类推
    sbit led1 = P2^1;
    sbit led1 = P2^2;
    sbit led1 = P2^3;
    sbit led1 = P2^4;
    sbit led1 = P2^5;
    sbit led1 = P2^6;
    sbit led1 = P2^7;
    void delay(unsigend z);
    void main()
    {
    	led0 = 0;   //此时P2.0引脚为低电平,LED点亮
    	delay(500);   //延时500毫秒
    	led0 = 1;    //将P2.0引脚为低电平,LED熄灭
    	
    	led1 = 0;
    	delay(500);
    	led1 = 1;
    	led2 = 0;delay(500);led2=1;led3=0;delay(500);led3=1;
    	led4 = 0;delay(500);led4=1;led5=0;delay(500);led5=1;
    	led6 = 0;delay(500);led6=1;led7=0;delay(500);led7=1;
    }
    void delay(unsigned z)
    {
    	unsigned x,y;
    	for(x = z;x>0;x--)
    		for(y = 110;y>0;y--);
    }
    
    • 按照上一篇的烧写方法就可以烧入单片机,观察到流水灯闪烁。

    6.使用字节控制(并行I/O口控制)流水灯

    • 编程思路:51系列单片机是8位单片机,每一组端口共有8个引脚,每个引脚可输出一个电平(0/1),一组端口可同时输出8个电平,正好构成一个字节。用字节操作来控制同时点亮几个流水灯的流动,要比位操作简单的多,即要点亮D2,D4,D6,D8,只需要P2端口从高位P2.7-P2.0 输出 0101 0101,将这8位二进制数转化为十六进制位0X55,只需要P2 = 0X55就行了。
    #include<reg52.h>
    #defined LED P2;  //宏定义 LED表示端口P2
    void delay(unsigned int z)//延时函数的另一种写法
    {
    	while(z--);
    }
    void main()
    {
    	LED = 0xlf;    //0xlf = 0001 1111
    	delay(30000);     
    	LED = 0x8f;     //0x8f = 1000 1111   
    	delay(30000);
    	LED = 0xc7;     //0xc7 = 1100 0111
    	delay(30000);
    	LED = 0xe3;    //0xe3 = 1110 0011 
    	delay(30000);
    	LED = 0xf1;     //0xf1 = 1111 0001
    	delay(30000);
    	LED = 0xf8;  //0xf8 = 1111 1000
    	delay(30000);
    	LED = 0x7c;   //0x7c = 0111 1100
    	delay(30000);
    	LED = 0x3e;  //0x3e = 0011 1110
    	delay(30000);
    }
    

    7.使用数组控制流水灯

    • 定义一个char类型(一个字节)的数组存放每个十六进制数,这样用一个for循环就可以循环赋值并延时
    #include<reg52.h>
    unsigned char table[] = {0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};//点亮第1、2、3、4···个灯的十六进制代码传入
    void delay(unsigned int z)
    {
    	unsigned int x,y;
    	for(x=z;x>0;x--)
    		for(y=110;y>0;y--);
    }
    void main()
    {
    	for(i=0;i<8;i++)
    	{
    		P2 = table[i];
    		delay(500);
    	}
    }
    
    
    展开全文
  • 这里使用的是AT89S51,利用定时器方式1实现跑马可以以5种速度变换(速度可以增加,只需要修改一点点的代码),并实现4种花样(用K1-K4键进行控制),也使用到了点阵。 实现过程 由于之前有做过按下按键使数码管...

    这里使用的是AT89S51,利用定时器方式1实现跑马灯可以以5种速度变换(速度可以增加,只需要修改一点点的代码),并实现4种花样(用K1-K4键进行控制),也使用到了点阵。

    1. 实现过程

      由于之前有做过按下按键使数码管显示的数字加一或减一的实验,本次的课程设计就使用此框架进行改造。
      首先是控制速度,我使用的方法是将速度储存在R0中,然后每次按下按键使R0加一,再调用数码管显示程序;接着控制花样,这个就让不同按键对应使不同的值存入R2中,最后在跑马灯花样控制时进行判断。

    2. 关于点阵
      点阵是我们一直想实现的内容,但是由于对74HC595的不熟悉,我们就利用P0口进行控制(还要向大佬学习),想要实现的是按下K4键点阵按照当前的速度进行移动,这里就遇到了一点点的挫折,因为忘记了延时程序还有使用到数码管显示程序,所以就造成了一些困惑,不管怎样,结果还是可以吧。

    3. 结果展示
      点阵按照一定的速度移动

    4. 代码

    		ORG 	0000H
    		LJMP 	MAIN
    		ORG		000BH
    		LJMP	TIMER0
    		ORG 	1000H
    		
    ;=========进行初始化==========================
    MAIN:   
    		CLR A			;把A清零
    		MOV R0,#0		;赋初值,用于记录当前的数值
    		MOV R1,#0
    		MOV R2,#0		;R2用于选择第几中变换方式
    		MOV P2,#0FEH	;跑马灯的初值
    		MOV 50H,#00H
    		
    LOOP:	LCALL DIS		;等待按键按下
    		LCALL KEY1
    		;LCALL TIME_S
    		SJMP LOOP
    
    KEY1:	
    ;=========判断按键是否按下====================
    		;LCALL DIS		;用于显示当前的数值(即使按键没有按下)
    		MOV P3,#0FFH	;将初值赋给P3,写入全一
    		MOV A,P3		;P3的值赋给A
    		CPL A			;累加器A中的内容取反
    		ANL A,#0FH		;检查是否有按键按下(只有四个按键)
    		JZ KEY1			;累加器为0,即如果没有按键按下就跳转回到KEY1
    		
    		LCALL DELAY		;延时程序去抖动
    		
    		MOV P3,#0FFH	;重新判断是否有按键按下
    		MOV A,P3
    		CPL A
    		ANL A,#0FH	
    		JZ KEY1			;若无按键按下,则继续循环
    		
    		JB ACC.0, PK1	;检查按键按下的情况
    		JB ACC.1, PK2
    		JB ACC.2, PK3
    		JB ACC.3, PK4
    		
    		
    PK1:	LCALL PKAY2		
    		LJMP PK
    PK2:  	LCALL PKAY1
    		LJMP PK
    PK3:	LCALL PKAY3
    		LJMP PK
    PK4:    LCALL PKAY4
    		LJMP PK
    PK:		RET		
    		
    ;=========对按键按下进行处理====================		
    ;处理K1按下的情况
    PKAY1:	CJNE R0,#5,ADD_OP	;判断是否等于5,即是否溢出,若无溢出,则跳转到加法运算
    		MOV R0,#0			;如果等于5的话,就让R0回到0
    ADD_OP:						;加法运算
    		INC R0		        ;R0加一
    		LCALL DIS			;调用数码管显示程序
    LIGHT:
    		MOV R2,#01H		    ;表示选择第一种花样
    		SJMP DIS_2	
    		RET
    ;处理K2按下的情况		
    PKAY2:  CJNE R0,#5,ADD_OP_2	;和K1的处理方式相似
    		MOV R0,#0	
    ADD_OP_2:					;加法运算
    		INC R0		        ;R0加一
    		LCALL DIS			;调用数码管显示程序
    LIGHT_2:
    		MOV R2,#02H			;表示选择第二种花样
    		SJMP DIS_2	
    		RET
    			
    ;处理K3按下的情况		
    PKAY3:	CJNE R0,#5,ADD_OP_3	;和K1的处理方式相似
    		MOV R0,#0
    ADD_OP_3:					;加法运算
    		INC R0		        ;R0加一
    		LCALL DIS			;调用数码管显示程序
    LIGHT_3:
    		MOV R2,#03H			;表示选择第三种花样
    		SJMP DIS_2	
    		RET	
    		
    ;处理K4按下的情况
    PKAY4:  CJNE R0,#5,ADD_OP_4 ;和K1的处理方式相似
    		MOV R0,#0
    ADD_OP_4:					;加法运算
    		INC R0				;R0加一
    		LCALL TIME_S		;调用数码管显示程序
    		LCALL TIME_S
    		;LCALL DIS
    LIGHT_4:				
    		MOV R2,#04H			;表示选择第四种花样
    		MOV P0,#00H
    		SJMP DIS_2
    		RET
    		
    DIS_2:
    		MOV R6,#0
    		MOV DPTR,#NUM_CLOCK	;这里根据R0表示取出跑马灯的不同速度,
    		MOV A,R0			;不同速度储存在NUM_CLOCK中,进行片选
    		MOVC A,@A+DPTR
    		MOV R3,A 			;利用不同的初值可以选择不同的速度
    		MOV 41H,A
    		SJMP DIS_3			;跳转到跑马灯程序
    
    KRET:
    		RET
    		
    		
    ;=========将结果展示在数码管上=================
    DIS:	PUSH ACC
    		MOV A,R0
    		MOV R1,A			;A的值用R1暂存
    		MOV DPTR ,#NUM		;取表值
    		
    		MOV A,R1
    		MOVC A,@A+DPTR		;选择不同的字形码
    		MOV P0,A 			;输送到P0口
    		LCALL TIME_S		;延时程序
    		
    		POP ACC 
    		RET
    
    ;=========跑马灯程序==========================		
    DIS_3:	MOV R3,41H	
    		MOV TMOD, #01H		  ;令T0为定时器方式1
    		MOV TH0, #0D8H		  ;装入定时初值
    		MOV TL0, #0F0H		  
    		
    		SETB EA			   	  ;开定时器中断总开关
    		SETB ET0			  ;启动T0计数
    		SETB TR0			  
    		CLR	A				  ;把A清零	
    		;MOV A,#0FEH
    		LJMP	KRET
    HERE:	AJMP HERE		
    TIMER0:	
    		MOV TH0, #0D8H		  ;重装定时初值
    		MOV TL0, #0F0H		
    		DJNZ R3,GOON
    		MOV R3,41H
    		CJNE R2,#01,A1
    		AJMP MOD1
    		AJMP A4
    A1:		CJNE R2,#02,A2
    		AJMP MOD2
    		AJMP A4
    A2:		CJNE R2,#03,A3
    		AJMP MOD3
    		AJMP A4
    A3:		CJNE R2,#04,A4
    		AJMP MOD4
    A4:		RETI
    GOON:	RETI
    
    MOD1:	MOV A,P2				;方式一:跑马灯从当前位置向后移动一位
    		RL A
    		MOV P2,A 
    		RETI
    		
    MOD2:	MOV A, P2				;方式二:跑马灯从当前位置向前移动一位  
    		RR A				   
    		MOV P2, A	
    		
    		RETI
    		
    MOD3:	MOV A, P2				;方式三:跑马灯从当前位置向前移动两位	
    		RL A
    		RL A
    		MOV P2, A
    		RETI
    MOD4:							;方式四:实现LED点阵的花样控制	
    		
    		MOV DPTR,#TABA
    		MOV A,R6
    		MOVC A,@A+DPTR
    		MOV P0,A
    		INC R6
    		CJNE R6,#5,RE_0
    RE_0:	RETI
    		MOV R6,#0
    		RETI
    ;=========延时程序============================		
    DELAY:  MOV R4,#200			;延时程序,其中调用DIS是为了防止按键按下时会闪烁			
    D:		DJNZ R4,D
    		RET
    
    TIME_S:
    		MOV R5,#250			;延时程序
    D2:		MOV R7,#250
    D3:		DJNZ R7,D3
    		DJNZ R5,D2
    		RET
    
    
    NUM_CLOCK:					;定时器以每次0.01s的节奏循环的次数
    		DB	00H, ,96H,064H,032H,14H  ;200 150 100 50 20
    		
    NUM:
    		DB 3FH,06H,5BH,4FH,66H
    		DB 6DH,7DH,07H,7FH,6FH
    
    TABA: 	DB 0FEH,0FDH,0FBH,0F7H,0EFH,0DFH,0BFH,07FH
    		DB 01H,02H,04H,08H,10H,20H,40H,80H
    		DB 0FEH,0FDH,0FBH,0F7H,0EFH,0DFH,0BFH,07FH
    		DB 01H,02H,04H,08H,10H,20H,40H,80H
    		
    		DB 0FEH,0FBH,0EFH,0BFH
    		DB 0FDH,0F7H,0DFH,07FH
    		DB 01H,04H,10H,40H
    		DB 02H,08H,20H,80H
    		
    		DB 0FEH,0F7H,0BFH
    		DB 0FDH,0EFH,07FH
    		DB 0FBH,0DFH
    		DB 01H,08H,40H
    		DB 02H,10H,80H
    		DB 04H,20H
    		
    		DB 0FEH,0EFH
    		DB 0FDH,0DFH
    		DB 0FBH,0BFH
    		DB 0F7H,07FH
    		DB 01H,10H
    		DB 02H,20H
    		DB 04H,40H
    		DB 08H,80H
    		
    ;TABB: 	DB 01H,02H,04H,08H,10H,20H,40H,80H
    
    		END
    
    
    展开全文
  • 51单片机入门教程(2)——实现流水一、搭建流水电路二、流水灯程序2.1 延时程序2.2 延时函数2.3 按字节寻址2.4 逻辑移位2.5 条件判断 一、搭建流水电路 在Proteus中搭建流水电路如图 二、流水灯程序 我们...

    一、搭建流水灯电路

    在Proteus中搭建流水灯电路如图
    在这里插入图片描述

    二、流水灯程序

    我们可以把流水灯看作依次点亮若干个灯。
    程序如下:

    #include <reg52.h>
    sbit led1 = P2^0;
    sbit led2 = P2^1;
    sbit led3 = P2^2;
    sbit led4 = P2^3;
    sbit led5 = P2^4;
    sbit led6 = P2^5;
    sbit led7 = P2^6;
    sbit led8 = P2^7;
    
    void main()
    {
        //点亮第一个灯
        led1 = 1;
        led2 = 0;
        led3 = 0;
        led4 = 0;
        led5 = 0;
        led6 = 0;
        led7 = 0;
        led8 = 0;
        //点亮第二个灯
        led1 = 0;
        led2 = 1;
        led3 = 0;
        led4 = 0;
        led5 = 0;
        led6 = 0;
        led7 = 0;
        led8 = 0;    
        //点亮剩余的灯
        //省略……
        while(1);
    }
    

    编译并下载程序到仿真中,观察现象发现只有第二个灯是亮的???
    什么鬼???

    2.1 延时程序

    单片机的执行指令速度非常快,一个晶振是12MHz的单片机执行一条指令的速度是微秒级的,所以点亮第一个灯的时间太短了,以至于我们根本没有察觉。
    因此我们需要一个延时的语句。
    实现延时的方法就是循环执行很多次空指令。程序如下:

    //延时一秒的程序
    int i,j;
    for(i = 0;i < 110; ++i)
    {
      for(j = 0; j < 1000; ++j)
      {
        ;//什么也不做
      }
    }
    
    

    然后我们就可以把流水灯的程序改成这样的:

    #include <reg52.h>
    sbit led1 = P2^0;
    sbit led2 = P2^1;
    sbit led3 = P2^2;
    sbit led4 = P2^3;
    sbit led5 = P2^4;
    sbit led6 = P2^5;
    sbit led7 = P2^6;
    sbit led8 = P2^7;
    
    void main()
    {
        int i,j;
       //点亮第一个灯
        led1 = 1;
        led2 = 0;
        led3 = 0;
        led4 = 0;
        led5 = 0;
        led6 = 0;
        led7 = 0;
        led8 = 0;
        //延时1秒 
    	for(i = 0;i < 110; ++i)
    	{
    	  for(j = 0; j < 1000; ++j)
    	  {
    	    ;//什么也不做
    	  }
    	}
        //点亮第二个灯
        led1 = 0;
        led2 = 1;
        led3 = 0;
        led4 = 0;
        led5 = 0;
        led6 = 0;
        led7 = 0;
        led8 = 0;    
        //点亮剩余的灯
        //省略……
        while(1);
    }
    

    编译并下载程序到仿真中,观察现象发现首先第一个灯亮,过了一会儿第二个灯亮。

    2.2 延时函数

    我们剩下的任务就是依次点亮每个灯,但是每次点亮一个灯就需要写一段延时程序,很麻烦!
    为了程序的可读性(toulan),可以把延时程序写成一个子函数,随时供我们使用。
    C语言中子函数的定义方式如下

    返回值类型 函数名 (参数1,参数2,……)
    {
      函数体;
    }
    

    这样我们就可以把延时函数写成这样:

    void delay1s()
    {
      int i,j;
      for(i = 0; i<110;++i)
      {
        for(j = 0; j<1000;++j)
        {
          //什么也不做
        }
      }
    }
    

    几点说明:

    • void:因为该延时函数不需要返回值,所以写为void
    • delay1s:该函数的函数名,命名需要符合C语言的标识符命名规则。
    • (): 不需要传入参数,所以括号中为空
      至此我们可以把流水灯程序写为以下形式:
    #include <reg52.h>
    
    sbit led1 = P2^0;
    sbit led2 = P2^1;
    sbit led3 = P2^2;
    sbit led4 = P2^3;
    sbit led5 = P2^4;
    sbit led6 = P2^5;
    sbit led7 = P2^6;
    sbit led8 = P2^7;
    
    //延时1s
    void delay1s()
    {	 
        int i ,j;
       	for(i = 0;i<110; ++i){
    	  for(j = 0;j<1000;++j){
    	    ;
    	  }
    	}
    }
    
    void main()
    {
        //点亮第一个灯
        led1 = 1;
        led2 = 0;
        led3 = 0;
        led4 = 0;
        led5 = 0;
        led6 = 0;
        led7 = 0;
        led8 = 0;
    
    	//延时1s
    	delay1s();
    
        //点亮第二个灯
        led1 = 0;
        led2 = 1;
        led3 = 0;
        led4 = 0;
        led5 = 0;
        led6 = 0;
        led7 = 0;
        led8 = 0;    
        //点亮剩余的灯
        //省略……
        while(1);
    }
    

    2.3 按字节寻址

    我们可以看到,上面的代码十分冗长,每次点亮一个灯需要8条语句,那么如何简化?
    比如把
    led1 = 1;led2 = 0; led3 = 0; led4 = 0; led5 = 0; led6 = 0; led7 = 0; led8 = 0;
    这8条语句替代为P2 = 0000 0001???
    答案是可以的。代码如下

    unsigned char a = 0x01;  //0x01是0000 0001的16进制形式
    P2 = a;//相当于led1 = 1;led2 = 0; led3 = 0;  led4 = 0; led5 = 0; led6 = 0; led7 = 0; led8 = 0;
    

    至此,我们可以把流水的代码优化为如下形式:

    #include <reg52.h>
    
    //延时1s
    void delay1s()
    {	 
        int i ,j;
       	for(i = 0;i<110; ++i){
    	  for(j = 0;j<1000;++j){
    	    ;
    	  }
    	}
    }
    
    void main()
    {
    	unsigned char a1 = 0x01 ;    // 0000 0001
    	unsigned char a2 = 0x02;    // 0000 0010
        //点亮第一个灯
    	P2 = a1;
    
    	//延时1s
    	delay1s();
    
        //点亮第二个灯
    	P2 = a2;    
        //点亮剩余的灯
        //省略……
        while(1);
    }
    

    2.4 逻辑移位

    依次点亮8个灯,每点亮一个灯都需要一句赋值语句还是很麻烦 。
    所以可以使用逻辑移位语句,每次赋值后,将数值左移一位。
    C语言逻辑左移代码如下:

    unsigned char a = 0x01;  //a = 0000 0001
    unsigned char b = a<<1;  // b = 0000 0010
    usingned char c = a<<3;   //c = 0000 1000
    

    至此,我们可以把流水灯的代码优化如下:

    #include <reg52.h>
    //延时1s
    void delay1s()
    {	 
        int i ,j;
       	for(i = 0;i<110; ++i){
    	  for(j = 0;j<1000;++j){
    	    ;
    	  }
    	}
    }
    
    void main()
    {
        //初始化
    	unsigned char a = 0x01;
        while(1)
    	{
    	  //循环点亮流水灯
    	  P2 = a;   
    	  a = a<<1;
    	  delay1s();
    	}
    }
    

    编译并下载程序到仿真中,观察现象发现8个灯依次亮过之后不再亮了。

    2.5 条件判断

    因为在移位操作中,当变量a的值为1000 0000时,再次执行左移操作,a 中的1就溢出了,因此a的值变为0000 0000,此时我们需要加一个判断,使a再次恢复为0000 0001
    C语言中,if条件判断使用方式如下

    if(判断条件)
    {
      //语句
    }
    

    当判断条件为真时,执行{ }中的语句。
    至此,流水灯代码可改成如下形式:

    #include <reg52.h>
    
    //延时1s
    void delay1s()
    {	 
        int i ,j;
       	for(i = 0;i<110; ++i){
    	  for(j = 0;j<1000;++j){
    	    ;
    	  }
    	}
    }
    
    void main()
    {
    	unsigned char a = 0x01;
        while(1)
    	{
    	  if(a == 0x00)   //如果高位溢出
    	  {
    	    a = 0x01;      //则恢复
    	  }
    	  //循环点亮led灯
    	  P2 = a;
    	  a = a<<1;
    	  delay1s();
    	}
    }
    
    展开全文
  • 单片机流水灯程序

    2019-03-03 23:21:38
    一、流水实验 1、设计要求 P1口接8个发光二极管,烧录程序后发光二极管依次点亮 2、硬件要求 利用proteus Isis仿真,选择器件,AT89C51、LED-BLUE、RES 3、软件设计 源程序: /*********************必要变量定义*...

    一、流水灯实验
    1、设计要求
    P1口接8个发光二极管,烧录程序后发光二极管依次点亮
    2、硬件要求
    利用proteus Isis仿真,选择器件,AT89C51、LED-BLUE、RES
    3、软件设计
    源程序:

    /*********************必要变量定义******************/
    #include<reg51.h>
    #include<intrns.h>
    typedef  unsigned  char  u8;
    typedef  unsigned  int  u16;
    #define  led  P1
    /****************延时程序**************/
    void  delay(u16  k)
    {
      u16  i ,j;
      for(i = 7; i < k; i++)
          for(j = 0;j < 124; j++);
     }
    /**********************主函数*******************/
    void  main()
    {
      u8 i;
      led = 0x01;
      delay(500);
     while (1)
    {
       /* for(i = 0;i < 8; i++)
        { 
         led = (0x01<<i);
         delay(500);
        }*/
       for(i = 0;i < 7; i++)
      {
         led = _crol_(led , 1); 
         delay(500);
       }
       for(i = 0;i < 7; i++)
      {
        led = _cror_(led , 1);
        delay(500);
       }
        }
     }
     
    ![在这里插入图片描述](https://img-blog.csdnimg.cn/2019030323184025.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21vb2Zvb2dvbw==,size_16,color_FFFFFF,t_70)
    如有任何错误或者不足之处,欢迎指正 ^ - ^.
    
    展开全文
  • #include &lt;reg51.h&gt; typedef unsigned char u8; typedef unsigned int u16;   #define PORT P1   void delay(unsigned char time) {  unsigned int j = 100000; ......

     

    #include <reg51.h>

    typedef unsigned char u8;

    typedef unsigned int u16;

     

    #define PORT P1

     

    void delay(unsigned char time)

    {

      unsigned int j = 100000;

      for(; time > 0; time--)

      for(;j > 0; j--);

    }

     

     

    void  main(void)

    {

      PORT = 0xff;

      temp = 0xff;

      while(1)

      {

          delay(200000);

          temp = temp << 1;

          

          if(PORT == 0)

          {

            PORT = 0xff;

          }

      }

    }

     

    //该程序为灯一个一个亮

    void main(void)

    {

      u8 w,i;

      

      while(1)

      {

        for(i = 0, w = 0x01; i < 8; i++)

        {

          PORT = ~w;

          w <<= 1;

          delay(2000);

        }

      }

    }

    //只有一个灯进行流水

    //花样流水灯

     

    /*-----------------------------------------------

      名称:花样流水灯

      编写:Jam

      日期:2018.7.21

      修改:无

      功能:花样灯

            第一遍:LED1~LED8一个灯流水一遍

            第二遍:LED8~LED1一个灯流水一遍

            第三遍:LED1~LED8依次点亮所有灯

            第四遍:LED8~LED1依次熄灭所有灯

            第五遍:通过查表将预存的花式灯点亮

    ------------------------------------------------*/

     

    #include <reg51.h>

     

    typedef unsigned char u8;

    typedef unsigned int u16;

     

    #define PORT P1

     

    u8 F_led[] = {0x7e,0x3c,0x18,0x00,

                  0x55,0xaa,0xdb,0x99};

     

    void Delay(u16 t)

    {

        while(--t);

    }

     

    void main(void)

    {

        u8 i;

        u8 temp;

        PORT = 0xff;

        

        while(1)

        {

            //从第一个灯开始亮

            for(i = 0, temp = 0x01; i < 8; i++)

            {

                PORT = ~temp;

                temp <<= 1;

                Delay(20000);

            }

            

            for(i = 0, temp = 0x80; i < 8; i++)

            {

                PORT = ~temp;

                temp >>= 1;

                Delay(20000);

            }

            

            

            for(i = 0; i < 8; i++)

            {

                PORT <<= 1;

                Delay(20000);

            }

            

            PORT = 0x80;

            

            for(i = 0,temp = 0x80; i < 8; i++)

            {

                PORT |=(temp >>= 1);

                Delay(20000);

            }

            

            for(i= 0; i < 8; i++)

            {

                PORT = F_led[i];

                Delay(20000);

            }

        }

    }

     

    展开全文
  • 51单片机心形——实现花样流水编程 心形效果图 心形原理图 编译软件:Keil uVision5 (如有需要可点此链接下载:https://download.csdn.net/download/qq_36931762/11343174) 单片机程序下载软件:STC-ISP ...
  • 花样彩灯程序设计

    2017-12-11 11:08:27
    #include void delay(unsigned int xms); int main(void) { int num[8]={1,2,4,8,16,32,64,128}; while(1) { int i=0; int x=3; int k=1; P1=0; for(i;i;i++) { for(x;x>=0;x--) { ...
  • 51单片机流水灯程序 汇编写的。 P1口,高电平亮。
  • 单片机流水灯程序要三十二个串行口全用,每个串行口八个LED。 悬赏分:20 - 提问时间2009-9-12 09:59 问题补充:用的是8051单片机,电路如下。其他回答:用的什么单片机? 看了电路图,就知道了。既不是32个串口,也...
  • 51单片机心形——实现串口通信编程 即其中一个单片机的按键控制另外一个单片机上的亮灭 心形效果图 心形原理图 编译软件:Keil uVision5 (如有需要可点此链接下载:...
  • 流水模块接在单片机的P1口,由原理图可以知道,在P1口给一个低电平即可点亮LED。相反,如果要LED熄灭,就要把P1口的电平变为高电平即可。要实现流水功能,我们只要将LED1~LED8依次点亮、熄灭,依始类推,8...
  • 单片机仿真keil编写程序74HC595是具有8位移位寄存器和一个存储器,三态输出功能。移位寄存器和存储器是分别的时钟。数据在SCK的上升沿输入,在RCK的上升沿进入的存储寄存器中去。如果两个时钟连在一起,则移位寄存器...
  • 使用汇编语言编写程序,设计一个用8051单片机控制的循环彩灯控制系统要求:1、能输出4种花型,并能由人工进行花型的切换。可以使用按键,也可以使用拨动开关来实现切换,方法不限。2、循环彩灯的循环速度可调。3、...
  • 51单片机键控花样循环 (大庆师范学院——机电工程学院——51单片机案例) 一、任务描述 加入两个按键K0和K1,可得到4种编码状态,用其控制4种花样循环方式。键控方式: ⑴ K0,K1均未按下,按照花样1循环; ⑵ K0...
  • @第一次在这里写博客呀~~我也是最近才学单片机的 51汇编按键控制霓虹灯程序设计 问题描述:用P2口控制8个LED,实现跑马灯程序,用软件延时实现1秒的扫描周期。 按键K1(P3.0)、K2(P3.1)作为输入。 K1(P3.1)作为跑马...
  • 心形流水灯套件1 设计...(5)掌握Keil软件的使用方法,以及如何创建文件和编写程序。(6)提高焊接能力以及实际问题分析能力。2 设计思路(1)设计一个用单片机控制的心形流水系统;(2)LED数量为32个;(3)...
  • 单片机流水的proteus仿真及C语言简介(链接) 从微信公众号把原文直接复制过来,内容如下(图片和表格可能丢失,格式可能错乱,故建议直接点击上述红色链接阅读): 明天就是元旦了,老板让我们提前下班跑路...
  • 所谓流水就是8个发光二极管(LED)轮流点亮,周而复始,实现多花样流水效果,如:8个发光二极管循环点亮(第①号亮、第②号亮……第⑧号亮,第①号亮、第②号亮……第⑧号亮,……,每次只亮一个);...
1 2 3 4 5 ... 10
收藏数 191
精华内容 76