51基础入门知识

最新推荐文章于 2023-07-13 09:37:08 发布
最新推荐文章于 2023-07-13 09:37:08 发布
阅读量443 收藏 3
点赞数 1
分类专栏： 蓝桥 文章标签： 单片机 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hvbkbb/article/details/128755256
版权

    • LED

#include "reg52.h"
//引入51头文件

typedef unsigned int uint;
typedef unsigned char uchar;
//重命名

sbit HC138_A = P2^5;
sbit HC138_B = P2^6;
sbit HC138_C = P2^7;
//sbit定义特殊功能寄存器的位变量
//定义好P25\P26\P27三个地址


//定义延时函数
void Delays(uint t)
{
    while(t--);
    while(t--);
}


void LEDRuning()
{
    uint i;
    
    HC138_A = 0;
    HC138_B = 0;
    HC138_C = 1;
    for(i = 0; i < 3; i++)
    {
        P0 = 0x00; //全部打开
        Delays(60000);
        Delays(60000);
        P0 = 0xff; //全部关闭
        Delays(60000);
        Delays(60000);
    }
    
    for(i = 1; i <= 8; i++)
    {
        P0 = 0XFF << i;
        Delays(60000);
        Delays(60000);
    }
    for(i = 1; i <= 8; i++)
    {
        P0 = ~(0XFF << i);
        Delays(60000);
        Delays(60000);
    }
}

void main()
{
        while(1)
        {
            LEDRuning();
        }
}

    • 蜂鸣器与继电器

#include "reg52.h"
//引入51头文件

typedef unsigned int uint;
typedef unsigned char uchar;
//重命名

sbit HC138_A = P2^5;
sbit HC138_B = P2^6;
sbit HC138_C = P2^7;
//sbit定义特殊功能寄存器的位变量
//定义好P25\P26\P27三个地址


//定义延时函数
void Delays(uint t)
{
    while(t--);
    while(t--);
}

void InitHC138(uint n)
{
    switch(n)
    {
        case 4:
            HC138_C = 1;
            HC138_B = 0;
            HC138_A = 0;
        break;
        case 5:
            HC138_C = 1;
            HC138_B = 0;
            HC138_A = 1;
        break;
        case 6:
            HC138_C = 1;
            HC138_B = 1;
            HC138_A = 0;
        break;
        case 7:
            HC138_C = 1;
            HC138_B = 1;
            HC138_A = 1;
        break;
            
    }
}

void OutPutP0(uint n, uchar dat)
{
    InitHC138(n);
    P0 = dat;
}

void LEDRuning()
{
    uint i;
    

    for(i = 0; i < 3; i++)
    {
        OutPutP0(4,0x00);
        Delays(60000);
        Delays(60000);
        OutPutP0(4,0xff);
        Delays(60000);
        Delays(60000);
    }
    
    for(i = 1; i <= 8; i++)
    {
        P0 = 0XFF << i;
        Delays(60000);
        Delays(60000);
    }
    
    OutPutP0(5,0x10);
    Delays(60000);
    Delays(60000);
    OutPutP0(5,0x00);
    
    
    for(i = 1; i <= 8; i++)
    {
        OutPutP0(4,~(0XFF << i));
        Delays(60000);
        Delays(60000);
    }
    OutPutP0(5,0x40);
    Delays(60000);
    Delays(60000);
    OutPutP0(5,0x00);
}

void Initsys()
{
    HC138_A = 1;
    HC138_B = 0;
    HC138_C = 1;
    
    P0 = 0X00;
}

void main()
{
        while(1)
        {
            Initsys();
            LEDRuning();
        }
}

3共阳数码管静态

#include <reg52.h>

typedef unsigned int uint;
typedef unsigned char uchar;

uchar code SMG_duanma[18] = 
    {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
     0x88,0x80,0xc6,0xc0,0x86,0x8e,
     0xbf,0x7f};//分别是0-9（对应下标），A-F，“-”，“.”

     
//配置HC138
void InitHC138(uchar n)
{
    switch(n)
    {
        case 4:
            P2 = (P2 & 0X1F) | 0X80;
        break;
        case 5:
            P2 = (P2 & 0X1F) | 0Xa0;
        break;
        case 6:
            P2 = (P2 & 0X1F) | 0Xc0;
        break;
        case 7:
            P2 = (P2 & 0X1F) | 0Xe0;
        break;
    }
}

//延时
void Delay(unsigned int n)
{
    while(n--);
    while(n--);
}

void ShowSMG_Bit(unsigned pos, uchar dat)
{
    
    InitHC138(6);  //数码管的位置
    P0 = 0x01 << pos;
    
    InitHC138(7);  //数码管的内容
    //Delay(100000000);
    //Delay(80000);
    P0 = SMG_duanma[dat];
    Delay(6000);
    Delay(6000);
    //P0 = 0xff;// 消影
    
}

void SMG_Static()
{
    uchar i,j;
    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 10; j++)
        {
            ShowSMG_Bit(i,j);
        }
        //Delay(600000);
        //Delay(600000);
    }
}

void Initsys()
{
    InitHC138(5);
    P0 = 0X00;
    InitHC138(4);
    P0 = 0XFF;
}

void main()
{
    while(1)
    {
        Initsys();
      SMG_Static();
    }
}

4，动态数码管

#include <reg52.h>

typedef unsigned int uint;
typedef unsigned char uchar;
//定义月份
uint yue = 1;
uchar code SMG_duanma[18] = 
    {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
     0x88,0x80,0xc6,0xc0,0x86,0x8e,
     0xbf,0x7f};//分别是0-9（对应下标），A-F，“-”，“.”


void Delay_SMG(uint n)
{
    while(n--);
}



//配置HC138
void SelectHC138(uchar channel)
{
    switch(channel)
    {
        case 4:
            P2 = (P2 & 0X1F) | 0X80;
        break;
        case 5:
            P2 = (P2 & 0X1F) | 0Xa0;
        break;
        case 6:
            P2 = (P2 & 0X1F) | 0Xc0;
        break;
        case 7:
            P2 = (P2 & 0X1F) | 0Xe0;
        break;
    }
}

//选择位码并显示
void DisplaySMG_Bit(uchar pos, uchar dat)
{
    SelectHC138(6);
    P0 = 0X01 << pos;
    SelectHC138(7);
    P0 = SMG_duanma[dat];
}

void Display_Dymaic()
{
    //uint i;
    DisplaySMG_Bit(0,2);
    Delay_SMG(500);
    DisplaySMG_Bit(1,0);
    Delay_SMG(500);
    DisplaySMG_Bit(2,2);
    Delay_SMG(500);
    DisplaySMG_Bit(3,2);
  Delay_SMG(500);
    DisplaySMG_Bit(4,16);
    Delay_SMG(500);
    DisplaySMG_Bit(5,16);
  Delay_SMG(500);
    
    DisplaySMG_Bit(6,yue / 10);
  Delay_SMG(500);
    DisplaySMG_Bit(7,yue % 10);
  Delay_SMG(500);
}

//初始化系统
void Initsys()
{
    SelectHC138(5);
    P0 = 0X00;//关闭蜂鸣器和继电器
    SelectHC138(4);
    P0 = 0XFF;//关闭LED
}

void Delay_yue(uint n)
{
    while(n--)
    {
        Display_Dymaic();
    }
}
void main()
{
    while(1)
    {
        Initsys();
        //DisplaySMG_Bit(2,6);
        Display_Dymaic();
        yue++;
        if(yue > 12)
        {
            yue = 1;
        }
        Delay_yue(200);
    }
}

5.独立按键

//任务1
#include <reg52.h>

typedef unsigned int uint;
typedef unsigned char uchar;

sbit S7 = P3^0;
sbit S6 = P3^1;
sbit S5 = P3^2;
sbit S4 = P3^3;

sbit L1 = P0^0;
sbit L2 = P0^1;
sbit L3 = P0^2;
sbit L4 = P0^3;

//配置HC138
void SelectHC138(uchar channel)
{
    switch(channel)
    {
        case 4:
            P2 = (P2 & 0X1F) | 0X80;
        break;
        case 5:
            P2 = (P2 & 0X1F) | 0Xa0;
        break;
        case 6:
            P2 = (P2 & 0X1F) | 0Xc0;
        break;
        case 7:
            P2 = (P2 & 0X1F) | 0Xe0;
        break;
    }
}

//初始化系统
void Initsys()
{
    SelectHC138(5);
    P0 = 0X00;//关闭蜂鸣器和继电器
    SelectHC138(4);
    P0 = 0XFF;//关闭LED
}


void DelayK(uint n)
{
    while(n--);
}

//配置独立按键
void ScanKeys_Alone()
{
    if(S7 == 0)
    {
        DelayK(100); //去抖
        if(S7 == 0) 
        {
            
            L1 = 0;
            while(S7 == 0);
            L1 = 1;
        }
    }
    if(S6 == 0)
    {
        DelayK(100); //去抖
        if(S6 == 0) 
        {
            
            L2 = 0;
            while(S6 == 0);
            L2 = 1;
        }
    }
    if(S5 == 0)
    {
        DelayK(100); //去抖
        if(S5 == 0) 
        {
            
            L3 = 0;
            while(S5 == 0);
            L3 = 1;
        }
    }
    if(S4 == 0)
    {
        DelayK(100); //去抖
        if(S4 == 0) 
        {
            
            L4 = 0;
            while(S4 == 0);
            L4 = 1;
        }
    }
}

void main()
{
    Initsys();
    while(1)
    {
        SelectHC138(4);
        ScanKeys_Alone();
    }
}

//任务2
#include <reg52.h>

typedef unsigned int uint;
typedef unsigned char uchar;

sbit S7 = P3^0;
sbit S6 = P3^1;
sbit S5 = P3^2;
sbit S4 = P3^3;

sbit L1 = P0^0;
sbit L2 = P0^1;
sbit L3 = P0^2;
sbit L4 = P0^3;
sbit L5 = P0^4;
sbit L6 = P0^5;

//配置HC138
void SelectHC138(uchar channel)
{
    switch(channel)
    {
        case 4:
            P2 = (P2 & 0X1F) | 0X80;
        break;
        case 5:
            P2 = (P2 & 0X1F) | 0Xa0;
        break;
        case 6:
            P2 = (P2 & 0X1F) | 0Xc0;
        break;
        case 7:
            P2 = (P2 & 0X1F) | 0Xe0;
        break;
    }
}

//初始化系统
void Initsys()
{
    SelectHC138(5);
    P0 = 0X00;//关闭蜂鸣器和继电器
    SelectHC138(4);
    P0 = 0XFF;//关闭LED
}


void DelayK(uint n)
{
    while(n--);
}

//状态变量
uchar stat_K = 0;
//配置独立按键
void ScanKeys_Alone()
{
    if(S7 == 0)
    {
        DelayK(100); //去抖
        if(S7 == 0) 
        {
            if(stat_K == 0)
            {
                L1 = 0;
                stat_K = 1;  //第一次按下，形成状态一
            }
            else if(stat_K == 1)
            {
                L1 = 1;
                stat_K = 0;  //第二次按下，初始化状态
            }
            while(S7 == 0); //等待按键松开
        }
    }
    if(S6 == 0)
    {
        DelayK(100); //去抖
        if(S6 == 0) 
        {
            if(stat_K == 0)
            {
                L2 = 0;
                stat_K = 2;   //第一次按下，形成状态二
            }
            else if(stat_K == 2)
            {
                L2 = 1;
                stat_K = 0;//第二次按下，初始化状态
            }
            while(S6 == 0); //等待按键松开
        }
    }
    if(S5 == 0)
    {
        DelayK(100); //去抖
        if(S5 == 0) 
        {
            if(stat_K == 1)
            {
                L3 = 0;
                while(L3 == 0);
                L3 = 1;
            }
            else if(stat_K == 2)
            {
                L4 = 0;
                while(L4 == 0);
                L4 = 1;
            }
        }
    }
    if(S4 == 0)
    {
        DelayK(100); //去抖
        if(S4 == 0) 
        {
            if(stat_K == 1)
            {
                L5 = 0;
                while(L5 == 0);
                L5 = 1;
            }
            else if(stat_K == 2)
            {
                L6 = 0;
                while(L6 == 0);
                L6 = 1;
            }
        }
    }
}

void main()
{
    Initsys();
    while(1)
    {
        SelectHC138(4);
        ScanKeys_Alone();
    }
}

6矩阵键盘

#include <reg52.h>

typedef unsigned int uint;
typedef unsigned char uchar;

sfr P4 = 0XC0;

sbit R1 = P3^0;
sbit R2 = P3^1;
sbit R3 = P3^2;
sbit R4 = P3^3;

sbit C4 = P3^4;
sbit C3 = P3^5;
sbit C2 = P4^2; //P36 -> P42
sbit C1 = P4^4; //P37 -> P44

void DelayK(uint n)
{
    while(n--);
}

uchar code SMG_duanma[18] = 
    {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
     0x88,0x80,0xc6,0xc0,0x86,0x8e,
     0xbf,0x7f};//分别是0-9（对应下标），A-F，“-”，“.”

//配置HC138
void SelectHC138(uchar channel)
{
    switch(channel)
    {
        case 4:
            P2 = (P2 & 0X1F) | 0X80;
        break;
        case 5:
            P2 = (P2 & 0X1F) | 0Xa0;
        break;
        case 6:
            P2 = (P2 & 0X1F) | 0Xc0;
        break;
        case 7:
            P2 = (P2 & 0X1F) | 0Xe0;
        break;
    }
}

//初始化系统
void Initsys()
{
    SelectHC138(5);
    P0 = 0X00;//关闭蜂鸣器和继电器
    SelectHC138(4);
    P0 = 0XFF;//关闭LED
}

void DisplayKeyNum(uchar dat)
{
    SelectHC138(6);
    P0 = 0X01;
    SelectHC138(7);
    P0 = SMG_duanma[dat];
}

uchar key_num;
void ScanKeyMulti()
{
    R1 = 0;
    R2 = R3 = R4 = 1;
    C1 = C2 = C3 = C4 = 1;
    if(C1 == 0)
    {
        key_num = 0;
        DisplayKeyNum(key_num);
        while(C1 == 0);
    }
    else if(C2 == 0)
    {
        key_num = 1;
        DisplayKeyNum(key_num);
        while(C2 == 0);
    }
    else if(C3 == 0)
    {
        key_num = 2;
        DisplayKeyNum(key_num);
        while(C3 == 0);
    }
    else if(C4 == 0)
    {
        key_num = 3;
        DisplayKeyNum(key_num);
        while(C4 == 0);
    }
    R2 = 0;
    R1 = R3 = R4 = 1;
    C1 = C2 = C3 = C4 = 1;
    if(C1 == 0)
    {
        key_num = 4;
        DisplayKeyNum(key_num);
        while(C1 == 0);
    }
    else if(C2 == 0)
    {
        key_num = 5;
        DisplayKeyNum(key_num);
        while(C2 == 0);
    }
    else if(C3 == 0)
    {
        key_num = 6;
        DisplayKeyNum(key_num);
        while(C3 == 0);
    }
    else if(C4 == 0)
    {
        key_num = 7;
        DisplayKeyNum(key_num);
        while(C4 == 0);
    }
    R3 = 0;
    R2 = R1 = R4 = 1;
    C1 = C2 = C3 = C4 = 1;
    if(C1 == 0)
    {
        key_num = 8;
        DisplayKeyNum(key_num);
        while(C1 == 0);
    }
    else if(C2 == 0)
    {
        key_num = 9;
        DisplayKeyNum(key_num);
        while(C2 == 0);
    }
    else if(C3 == 0)
    {
        key_num = 10;
        DisplayKeyNum(key_num);
        while(C3 == 0);
    }
    else if(C4 == 0)
    {
        key_num = 11;
        DisplayKeyNum(key_num);
        while(C4 == 0);
    }

    R4 = 0;
    R2 = R3 = R1 = 1;
    C1 = C2 = C3 = C4 = 1;
    if(C1 == 0)
    {
        key_num = 12;
        DisplayKeyNum(key_num);
        while(C1 == 0);
    }
    else if(C2 == 0)
    {
        key_num = 13;
        DisplayKeyNum(key_num);
        while(C2 == 0);
    }
    else if(C3 == 0)
    {
        key_num = 14;
        DisplayKeyNum(key_num);
        while(C3 == 0);
    }
    else if(C4 == 0)
    {
        key_num = 15;
        DisplayKeyNum(key_num);
        while(C4 == 0);
    }
    
}

void main()
{
    Initsys();
    while(1)
    {
        ScanKeyMulti();
    }
}

7.中断

#include <reg52.h>

typedef unsigned int uint;
typedef unsigned char uchar;

sbit L1 = P0^0;
sbit L8 = P0^7;

void Delay(uint t)
{
    while(t--);
    while(t--);
    while(t--);
}


//配置HC138
void SelectHC138(uchar channel)
{
    switch(channel)
    {
        case 4:
            P2 = (P2 & 0X1F) | 0X80;
        break;
        case 5:
            P2 = (P2 & 0X1F) | 0Xa0;
        break;
        case 6:
            P2 = (P2 & 0X1F) | 0Xc0;
        break;
        case 7:
            P2 = (P2 & 0X1F) | 0Xe0;
        break;
    }
}

//初始化系统
void Initsys()
{
    SelectHC138(5);
    P0 = 0X00;//关闭蜂鸣器和继电器
    SelectHC138(4);
    P0 = 0XFF;//关闭LED
}

void Working()
{
    SelectHC138(4);
    L1 = 0;
    Delay(60000);
    L1 = 1;
    Delay(60000);
}
//*******************************************
void Init_INT0()
{
    IT0 = 1;//下降沿触发
    EX0 = 1;
    EA = 1;
}

uchar stat_int = 0;
void ServiceINT0() interrupt 0
{
    stat_int = 1; //中断服务函数，尽量少做事情
}

void LEDINT()
{
    if(stat_int == 1)
    {
        L8 = 0;
        Delay(60000);
        Delay(60000);
        Delay(60000);
        Delay(60000);
        Delay(60000);
        Delay(60000);
        L8 = 1;
    }
}
//*******************************************

void main()
{
    Init_INT0();
    Initsys();
    while(1)
    {
        Working();
        LEDINT();
    }
}

8.定时器

#include <reg52.h>

typedef unsigned int uint;
typedef unsigned char uchar;

sbit L1 = P0^0;
sbit L8 = P0^7;

//配置HC138
void SelectHC138(uchar channel)
{
    switch(channel)
    {
        case 4:
            P2 = (P2 & 0X1F) | 0X80;
        break;
        case 5:
            P2 = (P2 & 0X1F) | 0Xa0;
        break;
        case 6:
            P2 = (P2 & 0X1F) | 0Xc0;
        break;
        case 7:
            P2 = (P2 & 0X1F) | 0Xe0;
        break;
    }
}

//初始化系统
void Initsys()
{
    SelectHC138(5);
    P0 = 0X00;//关闭蜂鸣器和继电器
    SelectHC138(4);
    P0 = 0XFF;//关闭LED
}
//********************************
void InitTime0()
{
    TMOD = 0X01;
    TH0 = (65535 - 50000) / 256;
    TL0 = (65535 - 50000) % 256;
    
    ET0 = 1;
    EA = 1;
    TR0 = 1;
}

uchar count = 0;
void ServiceTime0() interrupt 1
{
    TH0 = (65535 - 50000) / 256;
    TL0 = (65535 - 50000) % 256;
    count++;
    if(count % 10 == 0)
    {
        L1 = ~L1;
    }
    if(count == 100)
    {
        L8 = ~L8;
        count = 0;
    }
}
//********************************

void main()
{
    SelectHC138(4);
    InitTime0();
    Initsys();
    while(1)
    {
        
    }
}

9.秒表

#include <reg52.h>

sbit S4 = P3^3;
sbit S5 = P3^2;

typedef unsigned int uint;
typedef unsigned char uchar;

uchar code SMG_duanma[18] = 
    {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
     0x88,0x80,0xc6,0xc0,0x86,0x8e,
     0xbf,0x7f};//分别是0-9（对应下标），A-F，“-”，“.”

uchar t_m = 0;
uchar t_s = 0;
uchar t_005s = 0;
//配置HC138
void SelectHC138(uchar channel)
{
    switch(channel)
    {
        case 4:
            P2 = (P2 & 0X1F) | 0X80;
        break;
        case 5:
            P2 = (P2 & 0X1F) | 0Xa0;
        break;
        case 6:
            P2 = (P2 & 0X1F) | 0Xc0;
        break;
        case 7:
            P2 = (P2 & 0X1F) | 0Xe0;
        break;
    }
}

//在pos位码上，显示value段码
void DisplaySMG_Bit(uchar pos, uchar value)
{
    SelectHC138(6);
    P0 = 0X01 << pos;
    SelectHC138(7);
    P0 = value;
}

void DelaySMG(uint t)
{
    while(t--);
}

//数码管显示
void DisplayTime()
{
    DisplaySMG_Bit(7,SMG_duanma[t_005s%10]);
    DelaySMG(500);
    DisplaySMG_Bit(6,SMG_duanma[t_005s/10]);
    DelaySMG(500);
    DisplaySMG_Bit(5,SMG_duanma[16]);
    DelaySMG(500);
    
    DisplaySMG_Bit(4,SMG_duanma[t_s%10]);
    DelaySMG(500);
    DisplaySMG_Bit(3,SMG_duanma[t_s/10]);
    DelaySMG(500);
    DisplaySMG_Bit(2,SMG_duanma[16]);
    DelaySMG(500);
    
    DisplaySMG_Bit(1,SMG_duanma[t_m%10]);
    DelaySMG(500);
    DisplaySMG_Bit(0,SMG_duanma[t_m/10]);
    DelaySMG(500);
}

//********定时器相关函数*********
void InitTimer0()
{
    TMOD = 0x01;
    TH0 = (65535 - 50000) / 256;
    TL0 = (65535 - 50000) % 256;
    
    ET0 = 1;
    EA = 1;
    TR0 = 1;
}

void ServiceTimer0() interrupt 1
{
    TH0 = (65535 - 50000) / 256;
    TL0 = (65535 - 50000) % 256;
    t_005s++;
    if(t_005s == 20)
    {
        t_s++;
        t_005s = 0;
        if(t_s == 60)
        {
            t_m++;
            t_s = 0;
        }
        if(t_m == 99)
        {
            t_m = 0;
        }
    }
}
//*******************************

//按键去抖延时（uchar就够用）
void DelayK(uchar t)
{
    while(t--);
}

//按键扫描函数
void ScanKeys()
{
    if(S4 == 0)  //秒表启动/暂停
    {
        DelayK(100);
        if(S4 == 0)
        {
            TR0 = ~TR0;
            while(S4 == 0)
            {
                DisplayTime();
            }
        }
    }
    if(S5 == 0)  //秒表清零
    {
        DelayK(100);
        if(S5 == 0)
        {
            t_m = 0;
            t_s = 0;
            t_005s = 0;
            while(S5 == 0)
            {
                DisplayTime();
            }
        }
    }
}

//初始化系统
void Initsys()
{
    SelectHC138(5);
    P0 = 0X00;//关闭蜂鸣器和继电器
    SelectHC138(4);
    P0 = 0XFF;//关闭LED
}

void main()
{
    InitTimer0();
    Initsys();
    while(1)
    {
        DisplayTime();
        ScanKeys();
    }
}

10.PWM

#include <reg52.h>

typedef unsigned int uint;
typedef unsigned char uchar;

sbit L1 = P0^0;
sbit S7 = P3^0;

//配置HC138
void SelectHC138(uchar channel)
{
    switch(channel)
    {
        case 4:    //LED
            P2 = (P2 & 0X1F) | 0X80;
        break;
        case 5:    //蜂鸣器和继电器
            P2 = (P2 & 0X1F) | 0Xa0;
        break;
        case 6:    //位码
            P2 = (P2 & 0X1F) | 0Xc0;
        break;
        case 7:    //段码
            P2 = (P2 & 0X1F) | 0Xe0;
        break;
    }
}

//*********定时相关函数*********
uchar count = 0;
uchar pwm_duty = 0;
void InitTimer0()
{
    TMOD = 0x01;
    TH0 = (65535 - 100) / 256;
    TL0 = (65535 - 100) % 256;
    
    ET0 = 1;
    EA = 1;
}

void ServiceTimer0() interrupt 1 
{
    TH0 = (65535 - 100) / 256;
    TL0 = (65535 - 100) % 256;
    
    count++;
    if(count == pwm_duty)
    {
        L1 = 1;
    }
    else if(count == 100)
    {
        L1 = 0;
        count = 0;
    }
}
//*******按键相关函数********
uchar stat = 0;
void Delay(uint t)
{
    while(t--);
}


void ScanKeys()
{
    if(S7 == 0)
    {
        Delay(100);
        if(S7 == 0)
        {
            switch(stat)
            {
                case 0:
                    L1 = 0;
                    TR0 = 1;  //打开寄存器
                    pwm_duty = 10;
                    stat = 1;
                break;
                case 1:
                    pwm_duty = 50;
                    stat = 2;
                break;
                case 2:
                    pwm_duty = 90;
                    stat = 3;
                break;
                case 3:
                    L1 = 1;
                    TR0 = 0;
                  stat = 0;
                break;
            }
            while(S7 == 0);
        }
    }
}

//初始化系统
void Initsys()
{
    SelectHC138(5);
    P0 = 0X00;//关闭蜂鸣器和继电器
    SelectHC138(4);
    P0 = 0XFF;//关闭LED
}

void main()
{
    InitTimer0();
    Initsys();
    SelectHC138(4);
    while(1)
    {
        ScanKeys();
    }
}

11.串口通信

#include <reg52.h>

sfr AUXR = 0x8e;

typedef unsigned int uint;
typedef unsigned char uchar;

uchar urdat;

void SelectHC138(uchar channel)
{
    switch(channel)
    {
        case 4:    //LED
            P2 = (P2 & 0X1F) | 0X80;
        break;
        case 5:    //蜂鸣器和继电器
            P2 = (P2 & 0X1F) | 0Xa0;
        break;
        case 6:    //位码
            P2 = (P2 & 0X1F) | 0Xc0;
        break;
        case 7:    //段码
            P2 = (P2 & 0X1F) | 0Xe0;
        break;
    }
}

void InitUart()
{
    TMOD = 0X20;
    TH1 = 0XFD;
    TL1 = 0XFD;
    TR1 = 1;
    
    SCON = 0X50;
    AUXR = 0X00;
    
    ES = 1;
    EA = 1;
}



void SendByte(uchar dat)
{
    SBUF = dat;
    while(TI == 0);
    TI = 0;
}

void ServiceUart() interrupt 4
{
    if(RI == 1)
    {
        RI = 0;
        urdat = SBUF;
        SendByte(urdat + 1);
    }
}

//初始化系统
void Initsys()
{
    SelectHC138(5);
    P0 = 0X00;//关闭蜂鸣器和继电器
    SelectHC138(4);
    P0 = 0XFF;//关闭LED
}

void main()
{
    InitUart();
    Initsys();
    SendByte(0xa5);      
    SendByte(0x5a);
    while(1);
}

12.串口进阶

#include <reg52.h>

sfr AUXR = 0X8e;

typedef unsigned int uint;
typedef unsigned char uchar;

//配置HC138
void SelectHC138(uchar channel)
{
    switch(channel)
    {
        case 4:    //LED
            P2 = (P2 & 0X1F) | 0X80;
        break;
        case 5:    //蜂鸣器和继电器
            P2 = (P2 & 0X1F) | 0Xa0;
        break;
        case 6:    //位码
            P2 = (P2 & 0X1F) | 0Xc0;
        break;
        case 7:    //段码
            P2 = (P2 & 0X1F) | 0Xe0;
        break;
        case 0:    //锁住所有寄存器
            P2 = (P2 & 0X1F) | 0X00;
        break;
    }
}

void Initsys()
{
    SelectHC138(5);
    P0 = 0X00;//关闭蜂鸣器和继电器
    SelectHC138(4);
    P0 = 0XFF;//关闭LED
}

//*******************************
void InitUart()
{
    TMOD = 0x20;
    TH1 = 0XFD;  //在12兆下，9600波特率
    TL1 = 0XFD;
    TR1 = 1;
    
    SCON = 0X50; //模式1
    AUXR = 0X00;
    
    ES = 1;
    EA = 1;
}

uchar command = 0;
void ServiceUart() interrupt 4
{
    if(RI == 1)
    {
        command = SBUF;
        RI = 0;
    }
}

void SendByteUart(uchar dat)
{
    SBUF = dat;
    while(TI == 0);
    TI = 0;
}

void SendStringUart(uchar *str)
{
    while(*str != '\0')
    {
        SendByteUart(*str);
        str++;
    }
}
//*******************************
void Working()
{
     SelectHC138(4);
     if(command != 0)
     {
         switch(command & 0xf0)  //提取高四位
         {
             case 0xA0:
                 P0 = (P0 | 0X0F) & (~command | 0XF0); //保留高4位，反转低四位
                 command = 0X00;
             break;
             case 0xB0:
                 P0 = (P0 | 0XF0) & (~command << 4| 0X0F);
                 command = 0X00;
             break;
             case 0xC0:
                 SendStringUart("The System is Runing……\r\n");
                 command = 0X00;
             break;
         }
     }
}


void main()
{
    Initsys();
    InitUart();
    SendStringUart("Hello world");
    while(1)
    {
        Working();
    }
}

13.存储映射

#include <reg52.h>
#include "absacc.h"

typedef unsigned int uint;
typedef unsigned char uchar;

void Delay(uint t)
{
    while(t--);
    while(t--);
}

void LEDRuning()
{
    XBYTE[0X8000] = 0XF0;
    Delay(60000);
    Delay(60000);
    XBYTE[0X8000] = 0X0F;
    Delay(60000);
    Delay(60000);
    XBYTE[0X8000] = 0XFF;
    Delay(60000);
    Delay(60000);
}

void SMGRuning()
{
    uchar i;
    for(i = 0; i < 8; i++)
    {
        XBYTE[0XC000] = 0X01 << i;
        XBYTE[0XE000] = 0X00;
        Delay(60000);
        Delay(60000);
    }
    XBYTE[0XE000] = 0XFF;
    Delay(60000);
    Delay(60000);
}

void main()
{
    while(1)
    {
        LEDRuning();
        SMGRuning();
    }
}

14.基础技能综合实训案例解析

#include <reg52.h>

typedef unsigned int uint;
typedef unsigned char uchar;

sfr AUXR = 0X8e;

sbit S5 = P3^2;
sbit S4 = P3^3;

sbit L7 = P0^6;
sbit L8 = P0^7;

uchar code SMG_duanma[18] = 
    {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
     0x88,0x80,0xc6,0xc0,0x86,0x8e,
     0xbf,0x7f};//分别是0-9（对应下标），A-F，“-”，“.”

uchar time_005s = 0;
uchar time_s = 0;
uchar time_m = 0;
uchar time_h = 0;
     
void SMGDisplay();
     
//配置HC138
void SelectHC138(uchar channel)
{
    switch(channel)
    {
        case 4:    //LED
            P2 = (P2 & 0X1F) | 0X80;
        break;
        case 5:    //蜂鸣器和继电器
            P2 = (P2 & 0X1F) | 0Xa0;
        break;
        case 6:    //位码
            P2 = (P2 & 0X1F) | 0Xc0;
        break;
        case 7:    //段码
            P2 = (P2 & 0X1F) | 0Xe0;
        break;
        case 0:    //锁住所有寄存器
            P2 = (P2 & 0X1F) | 0X00;
        break;
    }
}

//在pos位码上，显示value段码
void DisplaySMG_Bit(uchar pos, uchar value)
{
    SelectHC138(6);
    P0 = 0X01 << pos;
    SelectHC138(7);
    P0 = value;
}

void Initsys()
{
    SelectHC138(5);
    P0 = 0X00;//关闭蜂鸣器和继电器
    SelectHC138(4);
    P0 = 0XFF;//关闭LED
}

void Delay_CL_CSMG(uint t)
{
    while(t--);
    while(t--);
}
void CheckSys()
{
    //检测LED
    uchar i;
    SelectHC138(4);
    for(i = 1; i <= 8; i++)
    {
        P0 = 0XFF << i;
        Delay_CL_CSMG(60000);
        Delay_CL_CSMG(60000);
    }
    for(i = 1; i <= 8; i++)
    {
        P0 = ~(0XFF << i);
        Delay_CL_CSMG(60000);
        Delay_CL_CSMG(60000);
    }
    //检测数码管
    for(i = 0; i < 8; i++)
    {
        DisplaySMG_Bit(i, 0X00);
        Delay_CL_CSMG(60000);
        Delay_CL_CSMG(60000);
    }
    P0 = 0XFF;
}
//*********************************
//本地控制
void Delay_K(uint t)
{
    while(t--);
}

void LocalCheck()
{
    SelectHC138(4);
    if(S4 == 0)
    {
        Delay_K(100);
        if(S4 == 0)
        {
            L8 = 0;
        }
        while(S4 == 0)
        {
            SMGDisplay();
        }
        L8 = 1;
    }
    if(S5 == 0)
    {
        Delay_K(100);
        if(S5 == 0)
        {
            L7 = 0;
        }
        while(S5 == 0)
        {
            SMGDisplay();
        }
        L7 = 1;
    }
}
//*********************************

//*********************************
//定时器
void InitTimer0()
{
    TMOD = 0X01;
    TH0 = (65535 - 50000) / 256;
    TL0 = (65535 - 50000) % 256;
    
    ET0 = 1;
    EA = 1;
    TR0 = 1;
}

void ServiceTimer0() interrupt 1
{
    TH0 = (65535 - 50000) / 256;
    TL0 = (65535 - 50000) % 256;
    time_005s++;
    if(time_005s == 20)
    {
        time_005s = 0;
        time_s++;
        if(time_s == 60)
        {
            time_s = 0;
            time_m++;
        }
        if(time_m == 60)
        {
            time_m = 0;
            time_h++;
        }
        if(time_h == 99)
        {
            time_h = 0;
        }
    }
}
//*********************************

//数码管显示
void Delay_SMG(uint t)
{
    while(t--);
}

void SMGDisplay()
{
    DisplaySMG_Bit(0, SMG_duanma[time_h / 10]);
    Delay_SMG(500);
    DisplaySMG_Bit(1, SMG_duanma[time_h % 10]);
    Delay_SMG(500);
    DisplaySMG_Bit(2, SMG_duanma[16]);
    Delay_SMG(500);
    
    DisplaySMG_Bit(3, SMG_duanma[time_m / 10]);
    Delay_SMG(500);
    DisplaySMG_Bit(4, SMG_duanma[time_m % 10]);
    Delay_SMG(500);
    DisplaySMG_Bit(5, SMG_duanma[16]);
    Delay_SMG(500);

    DisplaySMG_Bit(6, SMG_duanma[time_s / 10]);
    Delay_SMG(500);
    DisplaySMG_Bit(7, SMG_duanma[time_s % 10]);
    Delay_SMG(500);
    P0 = 0XFF;
}
//************************************
//串口通信
uchar command = 0;

void InitUart()
{
    TMOD = 0X20;
    TH1 = 0XFD;
    TL1 = 0XFD;
    TR1 = 1;
    
    SCON = 0X50; //模式1
    AUXR = 0X00;
    
    ES = 1;
    EA = 1;
}

void ServiceUart() interrupt 4
{
    if(RI == 1)
    {
        command = SBUF;
        RI = 0;
    }
}

void SendByteUart(uchar dat)
{
    SBUF = dat;
    while(TI == 0);
    TI = 0;
}


void UartWorking()
{
    if(command != 0)
    {
        SelectHC138(4);
        switch(command & 0XF0)
        {
             case 0xA0:
                 P0 = (P0 | 0X0F) & (~command | 0XF0); //保留高4位，反转低四位
                 command = 0X00;
             break;
             case 0xB0:
                 SendByteUart((time_h / 10 << 4) | (time_h % 10));
               SendByteUart((time_m / 10 << 4) | (time_m % 10));
               SendByteUart((time_s / 10 << 4) | (time_s % 10));
                 command = 0X00;
             break;
        }
    }
}
//************************************
void main()
{
    Initsys();
    CheckSys();
    InitTimer0();
    InitUart();
    InitUart();
    while(1)
    {
        LocalCheck();
        SMGDisplay();
        UartWorking();
    }
}

15.DS18B20

#include "reg52.h"
#include "onewire.h"

typedef unsigned int uint;
typedef unsigned char uchar;

uint temp = 0;

uchar SMG_duanma[18] = 
    {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
     0x88,0x80,0xc6,0xc0,0x86,0x8e,
     0xbf,0x7f};//分别是0-9（对应下标），A-F，“-”，“.”

uchar SMGDot_AC[10] = 
     {0X40,0X79,0X24,0X30,0X19,0X12,0X02,0X78,0X00,0X10};
     
//配置HC138
void SelectHC138(uchar channel)
{
    switch(channel)
    {
        case 4:    //LED
            P2 = (P2 & 0X1F) | 0X80;
        break;
        case 5:    //蜂鸣器和继电器
            P2 = (P2 & 0X1F) | 0Xa0;
        break;
        case 6:    //位码
            P2 = (P2 & 0X1F) | 0Xc0;
        break;
        case 7:    //段码
            P2 = (P2 & 0X1F) | 0Xe0;
        break;
        case 0:    //锁住所有寄存器
            P2 = (P2 & 0X1F) | 0X00;
        break;
    }
}
     
void Delay_SMG(uint t)
{
    while(t--);
}


//在pos位码上，显示value段码
void DisplaySMG_Bit(uchar pos, uchar value)
{
    SelectHC138(6);
    P0 = 0X01 << pos;
    SelectHC138(7);
    P0 = value;
}

void Initsys()
{
    SelectHC138(5);
    P0 = 0X00;//关闭蜂鸣器和继电器
    SelectHC138(4);
    P0 = 0XFF;//关闭LED
}

void Display_All(uchar dat)
{
    SelectHC138(6);
    P0 = 0XFF;
    SelectHC138(7);
    P0 = dat;
}

void DisplaySMG_Temp()
{
    DisplaySMG_Bit(7,SMG_duanma[temp % 10]);
    Delay_SMG(100);
    DisplaySMG_Bit(6,SMGDot_AC[(temp % 100) / 10]);
    Delay_SMG(100);
    DisplaySMG_Bit(5,SMG_duanma[temp / 100]);
    Delay_SMG(100);
    
    DisplaySMG_Bit(4,0XFF);
    Delay_SMG(100);
    DisplaySMG_Bit(3,0XFF);
    Delay_SMG(100);
    DisplaySMG_Bit(2,0XFF);
    Delay_SMG(100);
    DisplaySMG_Bit(1,0XFF);
    Delay_SMG(100);
    DisplaySMG_Bit(0,0XFF);
    Delay_SMG(100);
    Display_All(0XFF);
}

void Delay_temp(uint t)
{
    while(t--)
    {
        DisplaySMG_Temp();
    }
}

//**********************读取温度***************************/

void read_DS18B20_temp()
{
    uchar LSB,MSB;      //LSB低八位，MSB高八位
    //温度转换
    init_ds18b20();     //初始化DS18B20
    Write_DS18B20(0xcc);    //跳过ROM
    Write_DS18B20(0x44);    //开始温度转换
    Delay_OneWire(200);   //等待温度转换完成
    //读温度
    init_ds18b20();     //初始化DS18B20
    Write_DS18B20(0xcc);    //跳过ROM
    Write_DS18B20(0xbe);    //开始读温度
    //读温度
    
    LSB = Read_DS18B20();   //读取低八位数据
    MSB = Read_DS18B20();   //读取高八位数据
    
    temp = MSB;
    temp <<= 8;     //高八位右移8位
    temp = temp | LSB;  //将独立的高、低8位合并为16位
    
    if((temp & 0xf800) == 0x0000)    //判断temp的高五位来判断温度的正负，高5位全为0表示为正，全为1表示负
    {
        temp >>= 4;
        temp = temp * 10;   //temp先右移四位在乘上10相当于整数部分乘以0.625倍
        temp = temp + (LSB & 0x0f) * 0.625;  //整数部分 * 0.625 + 小数部分 *0.625
    }
}

void main()
{
    Initsys();
    while(1)
    {
        read_DS18B20_temp();
        DisplaySMG_Temp();
    }
}

16.DS12302

#include "reg52.h"
#include "ds1302.h"

typedef unsigned int uint;
typedef unsigned char uchar;

uchar Write_DS1302_adrr[7] = {0X80, 0X82, 0X84, 0X86, 0X88, 0X8A, 0X8C};
uchar Read_DS1302_adrr[7] = {0X81, 0X83, 0X85, 0X87, 0X89, 0X8B, 0X8D};
uchar Timer[7] = {0X24, 0X59, 0X23, 0X18, 0X04, 0X06, 0X20};

uchar code SMG_duanma[18] = 
    {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
     0x88,0x80,0xc6,0xc0,0x86,0x8e,
     0xbf,0x7f};//分别是0-9（对应下标），A-F，“-”，“.”

void DS1302_Config()
{
    char i;
    
    Write_Ds1302(0X81, 0X00);  //打开保护
    for(i = 0; i < 7; i++)
    {
        Write_Ds1302(Write_DS1302_adrr[i], Timer[i]);
    }
    
}

void Read_DS1302_Timer()
{
    uchar i;
    for(i = 0; i < 7; i++)
    {
        Timer[i] = Read_Ds1302(Read_DS1302_adrr[i]);
    }
}

//配置HC138
void SelectHC138(uchar channel)
{
    switch(channel)
    {
        case 4:    //LED
            P2 = (P2 & 0X1F) | 0X80;
        break;
        case 5:    //蜂鸣器和继电器
            P2 = (P2 & 0X1F) | 0Xa0;
        break;
        case 6:    //位码
            P2 = (P2 & 0X1F) | 0Xc0;
        break;
        case 7:    //段码
            P2 = (P2 & 0X1F) | 0Xe0;
        break;
        case 0:    //锁住所有寄存器
            P2 = (P2 & 0X1F) | 0X00;
        break;
    }
}

void Initsys()
{
    SelectHC138(5);
    P0 = 0X00;//关闭蜂鸣器和继电器
    SelectHC138(4);
    P0 = 0XFF;//关闭LED
}

//在pos位码上，显示value段码
void DisplaySMG_Bit(uchar pos, uchar value)
{
    SelectHC138(6);
    P0 = 0X01 << pos;
    SelectHC138(7);
    P0 = value;
}

void Delay_SMG(uint t)
{
    while(t--);
}


void Display_DS1302()
{
    DisplaySMG_Bit(0, SMG_duanma[Timer[2]/16]);
    Delay_SMG(100);
    DisplaySMG_Bit(1, SMG_duanma[Timer[2]%16]);
    Delay_SMG(100);
    DisplaySMG_Bit(2, SMG_duanma[16]);
    Delay_SMG(100);
    
    DisplaySMG_Bit(3, SMG_duanma[Timer[1]/16]);
    Delay_SMG(100);
    DisplaySMG_Bit(4, SMG_duanma[Timer[1]%16]);
    Delay_SMG(100);
    DisplaySMG_Bit(5, SMG_duanma[16]);
    Delay_SMG(100);
    
    DisplaySMG_Bit(6, SMG_duanma[Timer[0]/16]);
    Delay_SMG(100);
    DisplaySMG_Bit(7, SMG_duanma[Timer[0]%16]);
    Delay_SMG(100);
}

void main()
{
    Initsys();
    DS1302_Config();
    while(1)
    {
        Read_DS1302_Timer();
        Display_DS1302();
    }
}

17.555

#include <reg52.h>

typedef unsigned int uint;
typedef unsigned char uchar;

uint count_f = 0;   //计算频率
uint dat_f = 0;     //缓存上一秒频率
uchar count_t = 0;  //计算时间

uchar code SMG_duanma[18] = 
    {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
     0x88,0x80,0xc6,0xc0,0x86,0x8e,
     0xbf,0x7f};//分别是0-9（对应下标），A-F，“-”，“.”

//配置HC138
void SelectHC138(uchar channel)
{
    switch(channel)
    {
        case 4:    //LED
            P2 = (P2 & 0X1F) | 0X80;
        break;
        case 5:    //蜂鸣器和继电器
            P2 = (P2 & 0X1F) | 0Xa0;
        break;
        case 6:    //位码
            P2 = (P2 & 0X1F) | 0Xc0;
        break;
        case 7:    //段码
            P2 = (P2 & 0X1F) | 0Xe0;
        break;
        case 0:    //锁住所有寄存器
            P2 = (P2 & 0X1F) | 0X00;
        break;
    }
}

void Initsys()
{
    SelectHC138(5);
    P0 = 0X00;//关闭蜂鸣器和继电器
    SelectHC138(4);
    P0 = 0XFF;//关闭LED
}

void Delay_SMG(uint t)
{
    while(t--);
}

//在pos位码上，显示value段码
void DisplaySMG_Bit(uchar pos, uchar value)
{
    SelectHC138(6);
    P0 = 0X01 << pos;
    SelectHC138(7);
    P0 = value;
}

void Init_Timer()
{
    //定时器0用作计数，8位重装
    TH0 = 0XFF;
    TL0 = 0XFF;
    
    //定时器1用作定时，定时时间50ms
    TH1 = (65535 - 50000 + 1) / 256;
    TL1 = (65535 - 50000 + 1) % 256;
    
    TMOD = 0X16;//0001 0110
    
    ET0 = 1;
    ET1 = 1;
    EA = 1;
    
    TR0 = 1;
    TR1 = 1;
}

void Service_T0() interrupt 1
{
    count_f++;
}

void Service_T1() interrupt 3
{
    TH1 = (65535 - 50000 + 1) / 256;
    TL1 = (65535 - 50000 + 1) % 256;
    
    count_t++;
    if(count_t == 20)
    {
        dat_f = count_f;
        count_f = 0;
        count_t = 0;
    }
}

void Display_SMG_F()
{
    DisplaySMG_Bit(0, SMG_duanma[15]);
    Delay_SMG(100);
    
    DisplaySMG_Bit(1, 0XFF);
    Delay_SMG(100);
    
    DisplaySMG_Bit(2, 0XFF);
    Delay_SMG(100);
    
    if(dat_f > 9999)
    {
        DisplaySMG_Bit(3, SMG_duanma[dat_f / 10000]);
        Delay_SMG(100);
    }
    if(dat_f > 999)
    {
        DisplaySMG_Bit(4, SMG_duanma[(dat_f / 1000) % 10]);
        Delay_SMG(100);
    }
    if(dat_f > 99)
    {
        DisplaySMG_Bit(5, SMG_duanma[(dat_f / 100) % 10]);
        Delay_SMG(100);
    }
    if(dat_f > 9)
    {
        DisplaySMG_Bit(6, SMG_duanma[(dat_f / 10) % 10]);
        Delay_SMG(100);
    }
    DisplaySMG_Bit(7, SMG_duanma[dat_f % 10]);
    Delay_SMG(100);
    
    SelectHC138(6);
    P0 = 0XFF;
    SelectHC138(7);
    P0 = 0XFF;
}

void main()
{
    Initsys();
    Init_Timer();
    while(1)
    {
        Display_SMG_F();
    }
}

18.IIC

PCF8591

光敏电阻

//Light_read(0X01)光敏//0x03  RB2(AD)

uchar Light_read(uchar add)
{
    uchar temp;
    IIC_Start();
    IIC_SendByte(0X90);
    IIC_WaitAck();
    IIC_SendByte(add);
    IIC_WaitAck();
    IIC_Stop();
    
    IIC_Start();
    IIC_SendByte(0X91);
    IIC_WaitAck();
    temp = IIC_RecByte();
    IIC_Stop();
    return temp;
}

AT24C02

EEPROM

/*
EEPROM_write(0X01, 126);
delayms(5) //延时5ms
EEPROM_read(0X01)
*/

//读取
uchar EEPROM_read(uchar add)
{
    uchar temp;
    IIC_Start();
    IIC_SendByte(0XA0);
    IIC_WaitAck();
    IIC_SendByte(add);
    IIC_WaitAck();
    IIC_Stop();
    
    IIC_Start();
    IIC_SendByte(0XA1);
    IIC_WaitAck();
    temp = IIC_RecByte();
    IIC_Stop();
    return temp;
}


//写入
void EEPROM_write(uchar add, uchar dat)
{
    unsigned char temp;
    IIC_Start();
    IIC_SendByte(0XA0);
    IIC_WaitAck();
    IIC_SendByte(add);
    IIC_WaitAck();
    IIC_SendByte(dat);
    IIC_WaitAck();
    IIC_Stop();
}

DS1302

//Init_DS1302()就是初始化
//uchar shijian[] = {0, 30, 8, 0, 0, 0, 0};
//Read_DS1302()while里写

void Init_DS1302()
{
    uchar i, add;
    add = 0X80;  //写
    Write_Ds1302(0X8e, 0X00);
    for(i = 0; i < 7; i++)
    {
        Write_Ds1302(add, shijian[i]);
        add = add + 2;
    }
    Write_Ds1302(0X8e, 0X80);
}

void Read_DS1302()
{
    uchar i, add;
    add = 0X81;  //读
    Write_Ds1302(0X8e, 0X00);
    for(i = 0; i < 7; i++)
    {
        shijian[i] = Read_Ds1302(add);
        add = add + 2;
    }
    Write_Ds1302(0X8e, 0X80);
}
vv不说话
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C51单片机入门基础知识
07-21
### C51单片机入门基础知识详解 #### 一、电平特性概述 单片机是一种高度集成的微处理器芯片，广泛应用于各种嵌入式系统中。在其内部工作原理上，单片机处理的是数字信号，即信号只有两种状态：高电平和低电平。在...
电子入门基础知识
01-20
在大学里学习单片机的时候，我们认识到的单片机可能是下图的样子，这两种都叫51单片机，只不过是处理芯片似乎不一样，那单片机应该长什么样呢?这里就关系到了一个名词，叫做“”。　可能是如下这个样子的：　也可能...
【单片机】51单片机使用总结
Explore_Zhou
01-21 9294
目前很多电子类及信息类的专业都会开设单片机相关的课程及课程设计，但一般来说都会有51单片机的身影，因为51单片机确实非常适合入门，可以让初学者意识到**寄存器**的概念，从而加深对单片机工作原理的认识，**属于修炼内功心法的过程**。而且按照一般的课程设定，开设的课程都是以INTEL的**MCS51**系列单片机**80C51**型号为基础来进行讲述；而单片机课设往往用的是国内最常见的宏晶公司的**STC89Cxx**系列单片机，但好在后者基本兼容前者，而且功能更加强大，因此想以课程中所学的**80C51知
51单片机教程
最新发布
weixin_50624597的博客
07-13 1537
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、新手入门1.1 新建项目二、点LED灯2.1 点亮LED灯2.2 LED灯闪烁2.3 LED流水灯三、独立按键3.1 独立按键控制LED亮灭3.2 独立按键控制LED状态3.3 独立按键控制LED显示二进制3.4 独立按键控制LED移位四、数码管4.1 静态数码管显示4.2 动态数码管显示五、模块化编程和LCD16025.1 模块化编程5.2 LCD1602调试工具六、矩阵键盘6.1 矩阵键盘显示6.2 矩阵键盘密码锁七、定时
51单片机介绍
"謓泽"正在路上朝着"攻城狮"方向"前进四"!
08-26 2万+
大家好，我是泽奀，这篇博客我将说说关于51单片机知识介绍。在第一篇的时候我概述过C语言，没看的可以去看看https://blog.csdn.net/weixin_52632755/article/details/119757327(1)https://blog.csdn.net/weixin_52632755/article/details/119791540(2)，分别是《C语言概述1》《C语言概述2》。之所以要讲下51单片机介绍，是因为相信也有很多人对单片机感兴趣吧，当然也有很多是想学但是不清楚，或者.
51单片机详解
lijianhua003的博客
06-26 3万+
51大致就是对定时器，计算器，中断，串口的一些操作，前面我浅谈一下51的基本操作，后面我会对Sg-90舵机，超声波，LCD1602，DHT11温湿度传感器，IIC-OLED,HC-05蓝牙模块，esp8266-01sWI-FI模块，4G模块，4驱小车进行一个详细的汇总，希望能对大家有所帮助。......
51的堆栈
weixin_34293902的博客
07-30 208
2019独角兽企业重金招聘Python工程师标准>>> ...
51单片机基础入门.pdf
06-19
【51单片机基础知识】 51系列单片机是微控制器领域中极其经典的一款，源于Intel公司的MCS-51系列。这个系列的特点在于其广泛的兼容性，使得许多厂商如Atmel、Silicon Laboratories和STC等都有生产与之兼容的产品。...
单片机入门基础知识教程
08-20
单片机入门基础知识教程可以分为三大部分：单片机组成、单片机指令系统与汇编语言程序、MCU-51 CPU和存储器。 单片机组成 单片机要自动完成计算，它应该具有哪些最重要的部分呢？我们以打算盘为例计算一道算术题。...
51单片机轻松入门
10-24
本书以最新流行的不需要外部晶振与复位电路的可仿真的高速 STC15 系列单片机为核心，详细介绍了单片机内部功能模块，比如定时器、中断、串口、SPI 接口、片内比较器、ADC ...每个重要知识点都有简短精炼的实例作验证。
第九届蓝桥杯单片机省赛题‘彩灯控制器’程序实现
diksan的博客
03-11 3946
第九届蓝桥杯大赛单片机组省赛题程序题代码以及功能实现
51单片机笔记
cax1165
01-18 474
对于C语言编写的单片机程序，寄存器的声明包含在头文件"reg52.h"中 特殊的声明： sfr——特殊功能寄存器的数据声明，声明一个8位的寄存器。 sfr16——16位特殊功能寄存器的数据声明。 sbit——特殊功能位声明，也就是声明某一个特殊功能寄存器中的某一位。 bit——位变量声明，当定义一个位变量时可以使用此符号。   单片机最小系统运行的必要条件： 电源，晶振（时钟电路）...
8086汇编语言讲座
03-20
关于8086汇编语言，是与计算机原理相结合的，通过汇编语言可以加深对计算机原理的掌握和理解。另外汇编语言还是可以干成事的，比如破解，外挂等都会用到它。
51单片机——51单片机入门基础知识
热门推荐
糖炒栗子的博客
07-20 12万+
第一部分。单片机简介 MSC-51单片机指以8051为核心的单片机，由美国的Intel公司在1980年推出，80C51是MCS-51系列中的一个典型品种；其它厂商以8051为基核开发出的CMOS工艺单片机产品统称为80C51系列。 单片机：在一片集成电路芯片上集成微处理器（CPU）、存储器（ROM和RAM）、I/O接口电路，从而构成了单芯片微型计算机，即单片机（single chip Micr...
51单片机概述
王举
03-22 1536
51概述 alldatasheet.com 数据手册查询网址 上拉电阻：就是将不确定的信号通过一个电阻钳位在高电平，电阻同时起限流的作用，下拉同理，也就是将不确定的信号通过一个电阻钳位在低电平 当P0口作为输入/输出口时，上电复位后处于开漏模式p0口内无上拉电阻，所以做I/O口必须外接10k-4.7k的上拉电阻 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8PIQZW8Z-1647928172537)(image/55DF3E4D5C91EF85EFCEBB7FA07ACB
51的硬件结构
jacken3的博客
05-02 4355
什么是单片机？ 单片微型计算机是将计算机的基本部件微型化并集成到一块芯片上的微型计算机，是计算机微型化的典型代表之一，通常片内都含有中央处理单元（Cpu）、RAM、ROM、并行I/O,串行I/O定时器计数器、中断系统、系统时钟及系统总线。简称单片机。 单片机与微型计算机的区别？ 相同点：核心部件都是基于计算机的基本原理 ​ 衡量性能的主要计数指标基本相同 ​ 指令系统功能也大部分相同 ​ 程序运行原理也有很多相似之处 不同点：单片机将所有电路集成在一块芯片上，体积小，可靠性高。 ​
从51到csdn
吃水不忘挖井人
09-16 159
最近陆续整理博客内容，从51cto到这里，原地址博客已隐藏，原博客名称也是 Beyond_奈何 所以这里继续用这个名字，不再修改。现在的博客很多，选一个适合自己的也真是不容易。 有一个博客搬家的功能，可以通过申请达到自动拷贝，但是由于原博客从新公开需要审核，时间不定所以还是我一篇一篇整理，并且整理的过程，也发现之前的博客内容还有些地方需要完善一下，时隔几年时间，看看之前自己写的，发现很多问题，可能不利于他人看懂，当时记的时候也是为了重要的地方提个醒，就是忘了看看也能回忆起来，已经整理了两篇，看了之后发
C51编程入门教程：从基础知识到应用实践
"C51编程入门教程涵盖了C51的基础知识、延时程序、子程序设计、库函数调用、动态数码管显示、定时计数器应用以及串口通信等多个方面，旨在帮助初学者掌握C51编程的核心概念和技术。" 在C51编程中，首先要理解的是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值