zoukankan      html  css  js  c++  java
  • Keil C51学习 2 点亮LED灯

    P0口联接8个LED灯,P1^0~P1^7;

    #include<reg52.h>
    sbit LED=P1^0;
    void main()
    {
        LED=0;
        while(1);
    }

    //此方法使用1个字节对单个端口赋值
    P1 = 0xFF; //P1口全部为高电平,对应的LED灯全灭掉,
    //ff换算成二进制是 1111 1111

    P1 = 0xfe; //P1口的最低位点亮,可以更改数值是其他的灯点亮
    //0xfe是16进制,0x开头表示16进制数,
    //fe换算成二进制是 1111 1110

    全部取反,主函数中的代码修改为

     LED=~LED;      

    #include<reg52.h>
    unsigned int i,j;
    void main()
    {    
        while(1)
        {
            P1=~(1<<j++); 
            if(j==8)
            {
                j=0;
            }
            for(i=0;i<50000;i++);
        }    
    }
     1 void main (void)
     2 {
     3   while (1)         //主循环
     4   {                  //主循环中添加其他需要一直工作的程序
     5        LED=~LED;           
     6         //将P1.0口赋值 0,对外输出低电平
     7             delay(100);//执行100次
     8   }
     9 }
    10 void delay(int time)//延时函数
    11 {
    12      int i=0;
    13      while(time--)
    14      {
    15          i=4000;
    16          while(i--);
    17      }
    18 }
    延时闪烁
     1 void delay(int time)//延时函数
     2 {
     3      int i=0;
     4      while(time--)
     5      {
     6          i=4000;
     7          while(i--);
     8      }
     9 }
    10 void main (void)
    11 {
    12   while (1)         //主循环
    13   {                  //主循环中添加其他需要一直工作的程序
    14               
    15     unsigned char i;  //定义一个无符号字符型局部变量 i 取值范围 0~255
    16     //P1=0xfe;           //赋初始值
    17         for(i=0;i<8;i++)   //加入 for循环,表明for循环大括号中的程序循环执行8次
    18         {
    19             P1<<=1;
    20             delay(100);//执行100次
    21         }
    22   }
    23 }
    延时左移
     1 void delay(int time)//延时函数
     2 {
     3      int i=0;
     4      while(time--)
     5      {
     6          i=4000;
     7          while(i--);
     8      }
     9 }
    10 void main (void)
    11 {
    12                    
    13 unsigned char i;  //定义一个无符号字符型局部变量 i 取值范围 0~255
    14 delay(100);
    15 P1=0xfe;           //赋初始值
    16     while (1)         //主循环
    17   {
    18  for(i=0;i<8;i++)   //加入 for循环,表明for循环大括号中的程序循环执行8次
    19   {
    20    delay(100);
    21    P1<<=1;
    22    P1=P1|0x01;     //左移后,最右端自动赋值0,所以需要该语句赋值1
    23   } 
    24   P1=0xfe;           //重新赋初始值
    25   //主循环中添加其他需要一直工作的程序
    26   }
    27 }
    循环左移
     1 sbit LED0=P1^0;
     2 void delay(int i)//延时函数
     3 {
     4          while(i--);
     5 }
     6 void main (void)
     7 {
     8                        
     9 unsigned int CYCLE=600,PWM_LOW=0;//定义周期并赋值
    10 while (1)         //主循环
    11   {
    12  LED0=1;
    13  delay(60000);        //特意加延时,可以看到熄灭的过程
    14  for(PWM_LOW=1;PWM_LOW<CYCLE;PWM_LOW++){ //PWM_LOW表示低
    15  //电平时间,这个循环中低电平时长从1累加到CYCLE(周期)的值,即600次
    16 
    17            LED0=0;        //点亮LED  
    18            delay(PWM_LOW);//延时长度,600次循环中从1加至599
    19            LED0=1;        //熄灭LED
    20           delay(CYCLE-PWM_LOW);//延时长度,600次循环中从599减至1
    21      
    22    }
    23  LED0=0;
    24  for(PWM_LOW=CYCLE-1;PWM_LOW>0;PWM_LOW--){ //与逐渐变亮相反的过程
    25 
    26            LED0=0;
    27            delay(PWM_LOW);
    28            LED0=1;
    29           delay(CYCLE-PWM_LOW);
    30    }
    31                      //主循环中添加其他需要一直工作的程序
    32   }
    33 }
    呼吸灯

     流水灯

     1 #include<reg52.h> //包含头文件,一般情况不需要改动,
     2                   //头文件包含特殊功能寄存器的定义
     3 
     4 void delay100ms(unsigned char num);
     5 /*------------------------------------------------
     6                  流水灯
     7 ------------------------------------------------*/
     8 void main (void)
     9 {
    10     unsigned char led=0xff,mask=0x1,flag=0;
    11     //unsigned char tflag=0,time=100;
    12     while(1)
    13     {
    14         P1=led^mask; //mask为0 全灭
    15         delay100ms(5); //延时500ms
    16         if(0x80==mask)
    17             flag=0;// 让mask向右位移
    18         if(0x1==mask)
    19             flag=1;//让mask向左位移
    20         flag?(mask<<=1):(mask>>=1);
    21     }
    22 }
    23 
    24 void delay100ms(unsigned char num)
    25 {
    26     unsigned char n,m;
    27     for(;num;num--)
    28     {
    29         for(n=200;n;n--)
    30         {
    31             for(m=250;m;m--);
    32         }
    33     }
    34 }
    流水灯

    函数实现流水灯

     1 #include<reg52.h> //包含头文件,一般情况不需要改动,
     2 #include<intrins.h>
     3 #define uchar unsigned char    //头文件包含特殊功能寄存器的定义
     4 void delay100ms(unsigned char num);
     5 /*------------------------------------------------
     6                 利用_crol_、_cror_实现流水灯
     7 _crol_ 将char型变量循环左移
     8 _cror_ 将char型变量循环右移
     9 ------------------------------------------------*/
    10 void main (void)
    11 {
    12     uchar x=0x3;
    13     bit flag=0;
    14     while(1)
    15     {
    16         P1=x; 
    17         delay100ms(10);
    18         if(0x3==x)
    19             flag=0;
    20         else if(0xc0==x)
    21             flag=1;
    22         flag?(x=_cror_(x,2)):(x=_crol_(x,2));
    23     }
    24 }
    25 //延时函数
    26 void delay100ms(unsigned char num)
    27 {
    28     unsigned char n,m;
    29     for(;num;num--)
    30     {
    31         for(n=200;n;n--)
    32         {
    33             for(m=250;m;m--);
    34         }
    35     }
    36 }
    流水灯2

    指针实现流水灯

    #include <reg52.h>
    void delay(unsigned int);
    //指针实现流水灯代码
    unsigned char dis[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
    void main()
    {
        unsigned char i,*p;//定义一个无符号字符型变量i各一个指向无符号字符型变量的指针变量P
        while(1)
        {
            p=&dis[0];//把数组中第一个成员数据(0xFE)所占的内存地址赋给指针变量P
            for(i=0;i<8;i++)
            {
                    P1=*p;//取指针指向的数组元素,并拷贝给单片机的P0口
                    p++;  //指针加1,指向数组的下一个元素
                delay(10);
            }
        }
    }
    void delay(unsigned int i)
    {
        unsigned int j;
        for(;i!=0;i--)
        {
            for(j=3000;j!=0;j--);
        }
    }
    指针实现流水灯

    花样流水灯

     1 #include<reg52.h> //包含头文件,一般情况不需要改动,
     2 #define uchar unsigned char    //头文件包含特殊功能寄存器的定义
     3 uchar code tab[]={
     4     0x1,0x2,0x4,0x8,0x10,0x20,0x40,0x80, //正向流水灯
     5   0x40,0x20,0x10,0x8,0x4,0x2,0x1,0x0,  //反向流水灯
     6     0x55,0xaa,0x55,0xaa,0x55,0xaa,0x0,     //隔灯闪烁
     7     0x0f,0xf0,0x0f,0xf0,0x0,                         //高四盏 底四盏闪烁
     8     0xcc,0x33,0xcc,0x33,0xcc,0x33,0x0         //隔两盏灯闪烁
     9 };
    10 void delay100ms(unsigned char num);
    11 /*------------------------------------------------
    12                  花样流水灯
    13 ------------------------------------------------*/
    14 void main (void)
    15 {
    16     uchar x;
    17     while(1)
    18     {
    19         for(x=0;x<35;x++)
    20         {
    21             P1=tab[x]; 
    22             delay100ms(10);
    23         }
    24     }
    25 }
    26 
    27 void delay100ms(unsigned char num)
    28 {
    29     unsigned char n,m;
    30     for(;num;num--)
    31     {
    32         for(n=200;n;n--)
    33         {
    34             for(m=250;m;m--);
    35         }
    36     }
    37 }
    花样流水灯

    指针,二维数组花样流水灯

    #include <reg52.h>
    void delay(unsigned int ); //延时函数的声明
    //*******定义一个二维数组,存储40个彩灯数据。*********** 
    unsigned char dis[5][8]= 
    { 
    {0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f} 
    ,{0x7f,0xbf,0xdf,0xef,0xf7,0xfb,0xfd,0xfe} 
    ,{0x00,0xff,0x00,0xff,0x00,0xff,0x00,0xff} 
    ,{0x7f,0x3f,0x1f,0x0f,0x07,0x03,0x01,0x00} 
    ,{0x00,0x01,0x03,0x07,0x0f,0x1f,0x3f,0x7f} 
    }; 
    /***********************************主函数************************************/ 
    void main(void) 
    {unsigned char i; 
     unsigned char j; 
     unsigned char *p;//定义一个指向无符号字符型的指针变量。
    while(1) 
    { p=&dis[0][0]; //取数组的首地址,也就是第0个元素的所在的地址。
     for(j=0;j<5;j++) //用两层嵌套循环引用彩灯数组中的数据,行引用,一共5行。
     for(i=0;i<8;i++) //用两层嵌套循环引用彩灯数组中的数据,列引用,一共8列。
     { 
     P1=*p++; //取数组中数据,同时指针加1。
     delay(10); //调用延时函数。
     } 
     } 
    } 
    /*******************************延时函数*************************************/ 
    void delay(unsigned int i) 
    { 
     unsigned int j; 
     for(;i!=0;i--) 
     for(j=3000;j!=0;j--); 
    }
    指针,二维数组花样流水灯

    精确定时1秒移动走马灯

    #include<reg52.h>//包含访问sfr库函数
    #include<intrins.h>//包含访问内联库函数
    #include <absacc.h>  
    typedef unsigned int uint;      //对数据类型进行声明定义
    typedef unsigned char uchar;
    typedef unsigned long ulong;
    bit ldelay=0;
    uchar speed=10;
    uchar code ledp[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};//预定的写入 P1 的值
    uchar ledi;//用来指示显示顺序
    /*
        精确定时1秒闪烁LED
     */
     uint count;
    
    unsigned char led=0xff,mask=0x1;
    main()
    {
            RCAP2H=0X10; //赋值52 0X1000,溢出30次等于1秒
            RCAP2L=0X00;
            TR2=1;    //启动定时器
            ET2=1;    //打开定时器2中断
            EA=1;        //打开总中断
        while(1)
        {
             if(ldelay)
            {
                ldelay=0; //清除标记
                 P1=ledp[ledi]; //读出一个值送到 P1 口
                 ledi++; //指向下一个
                 if(ledi==8) 
                 { 
                    ledi=0; //到了最后一个灯就换到第一个
                 } 
            }
             if(!K1)speed=30; //检查到按键,设置对应的跑马速度
             if(!K2)speed=15; 
             if(!K3)speed=6; 
             if(!K4)speed=3;
        }
    }
    
    //定时器2中断
    timer2() interrupt 5    //定时器2中断是5号
    {
        static uchar t;
        TF2=0;
        t++;
        if((t==speed)||(t>30))
        {
            t=0;
             ldelay=1;
        }
    }
    精确定时1秒闪烁LED

    单按键10级调速走马灯

    #include<reg52.h>//包含访问sfr库函数
    #include<intrins.h>//包含访问内联库函数
    #include <absacc.h>  
    
    typedef unsigned int uint;      //对数据类型进行声明定义
    typedef unsigned char uchar;
    typedef unsigned long ulong;
    
    sbit K1=P3^2;           //包含绝对地址访问库函数
    bit ldelay=0;
    uchar speed=10;//设置一个变量保存默认的跑马灯的移动速度
    uchar speedlever=0; //保存当前的速度档次
    //一个按键控制的 10 级变速跑马灯试验
    uchar code ledp[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};//预定的写入 P1 的值
    uchar ledi;//用来指示显示顺序
    uint n;
    /*
        精确定时1秒闪烁LED
     */
    
    unsigned char led=0xff,mask=0x1;
    main()
    {
            RCAP2H=0X10; //赋值52 0X1000,溢出30次等于1秒
            RCAP2L=0X00;
            TR2=1;    //启动定时器
            ET2=1;    //打开定时器2中断
            EA=1;        //打开总中断
        while(1)
        {
             if(ldelay)
            {
                ldelay=0; //清除标记
                 P1=ledp[ledi]; //读出一个值送到 P1 口
                 ledi++; //指向下一个
                 if(ledi==8) 
                 { 
                    ledi=0; //到了最后一个灯就换到第一个
                 } 
            }
             if(!K1) //检查到按键,设置对应的跑马速度
             {
                for(n=0;n<1000;n++); //等待按键稳定
                { 
                     while(!K1); //等待按键松开
                     for(n=0;n<1000;n++); //等待按键稳定松开
                     speedlever++; 
                     if(speedlever==10)speedlever=0; 
                     speed=speedlever*3; //档次和延时之间的预算法则,也可以用查表方法,做出不规则的法则
                }
        }
    }
    
    
    }
    //定时器2中断
    timer2() interrupt 5    //定时器2中断是5号
    {
        static uchar t;
        TF2=0;
        t++;
        if((t==speed)||(t>30))
        {
            t=0;
             ldelay=1;
        }
    }
    十级调速
  • 相关阅读:
    Maven私服安装
    Maven运行的方式
    Maven传递依赖的范围
    Maven子模块
    Maven父工程
    Maven项目指定JDK版本
    Maven传递依懒
    Maven概念模型
    Swift -欢迎界面1页, 延长启动图片的显示时间(LaunchImage)
    Swift
  • 原文地址:https://www.cnblogs.com/bymeet/p/14347715.html
Copyright © 2011-2022 走看看