vv啊vv

51基础入门知识

- 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 

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 

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 

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 

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 

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 

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 

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 

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 

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 

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 

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 
#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 

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 

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);
}

你可能感兴趣的:(蓝桥,单片机)

基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程极客小张 stm32 qt 机器人物联网人机交互毕业设计 c语言
一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
51单片机——I2C总线存储器24C02的应用老侯（Old monkey） 51单片机嵌入式硬件单片机
目标实现功能单片机先向24C02写入256个字节的数据，再从24C02中一次读取2个字节的数据、并在数码管上动态显示，直至读完24C02中256个字节的数据。1.I2C总线简介I2C总线有两根双向的信号线，一根是数据线SDA,另一根是时钟线SCL。I2C总线通过上拉电阻接正电源，因此，当总线空闲时为高电平。2.I2C通信协议起始信号、停止信号由主机发出。在数据传送时，当时钟线为高电平时，数据线上的
嵌入式单片机中数码管基本实现方法嵌入式开发星球单片机项目实战操作之优秀单片机
1.点亮数码管本节课利用已经学习的LED知识去控制一个8位数码管。本节的原理比较简单。不需要多少时间讲。更多时间是跟大家一起编码调试，从中学习一些编码思路和学习方法。1.1.什么是数码管数码管是什么？下图就是一个数码管从硬件上个看，其实就是8个LED组合在一起。8个LED应该有16个引脚，但是数码管上只有10个引脚。为什么呢？请看下图：1个LED有两个引脚，要控制LED，1个引脚接控制信号，另外一
蓝桥杯18小白第5题 @liu666 蓝桥杯算法职场和发展
思维，#includeusingnamespacestd;#defineintlonglongconstintn=1e6+11;inta,b[n],c[n],d,k[n];structs{intx,y,z;}q[n];boolcmp(sa1,sa2){returna1.z>a;for(inti=1;i>q[i].x;}for(inti=1;i>q[i].y;q[i].z=q[i].x+q[i].y
4×4矩阵键盘详解（STM32）辰哥单片机设计 STM32传感器教学矩阵计算机外设 stm32 嵌入式硬件单片机传感器
目录一、介绍二、传感器原理1.原理图2.工作原理介绍三、程序设计main.c文件button4_4.h文件button4_4.c文件四、实验效果五、资料获取项目分享一、介绍矩阵键盘，又称为行列式键盘，是用4条I/O线作为行线，4条I/O线作为列线组成的键盘。在行线和列线的每一个交叉点上设置一个按键，因此键盘中按键的个数是4×4个。这种行列式键盘结构能够有效地提高单片机系统中I/O口的利用率，节约单
学单片机怎么在3-5个月内找到工作？无际单片机编程单片机嵌入式开发物联网 stm32 c语言
每个初学者，都如履薄冰，10几年前，我自学单片机时，也一样。想通过学习，找一份体面点的工作，又害怕辛辛苦苦学出来，找不到工作。好在，当初执行力，还算可以，自学java没成功，后面自学单片机，成功入行了。转眼间，毕业到现在有13年了，马上也到了奔4的年纪。这13年一直在跟单片机打交道，打过工，创过业，对行业，对企业，都有一定的认知，坚持看完这篇内容，相信能帮你少走几个月弯路。有些老铁，加了我很久，时
51单片机：P3.3口输入/P 1口输出实验 li星野单片机
51单片机：P3.3口输入/P1口输出实验一、实验内容1P3.3口做输入口，外接一脉冲,每输入一个脉冲,P1口按十六进制除2（乘2）。2.P1口做输出口，P1口接的8个发光二极管L1—L8按十六进制除2（乘2）方式点亮。二、仿真图三、代码实现C语言实现：#include#includesbitKEY=P3^3;voiddelay10ms(void);voidmain(){charnum=0xfe;
2020-11-12 写单片机内存的脚本 nc openocd 事务自动测试 linuxScripter
这是写单片机内存的脚本：z@z-ThinkPad-T400:~/zworkT400/EDA_heiche/zREPOgit/simple-gcc-stm32-project$catz.wholeRun.oneCase.cmdcattmp6.toWrite|awk'{system("echomwb"$1""$2"|nclocalhost4444");}'catUSER/DEBUG/debug.h|g
单片机中断 woainizhongguo. STM32单片机原理解析篇单片机嵌入式硬件
**在51单片机中，中断向量表的地址是如何被设置的？**在51单片机中，中断向量表的设置是中断系统的核心部分，它定义了中断服务程序的入口地址。以下是中断向量表的设置方法：中断向量表的位置：51单片机的中断向量表通常位于程序存储器的起始位置，即地址0x0000到0x000F（对于双字节的中断向量，实际占用0x0000到0x001F）。这些地址是固定的，由单片机的硬件设计决定。中断向量的分配：每个中断
烧粪毛草台
昨天下午到学校前的河边走走，刚下河堤，抬眼便见到小河对岸的西头远远的升起了袅袅的白烟。这是有人在烧粪。望着散漫升空的烟雾，久违的感觉突然浸透全身，生活在这个城市里，真是好久没有见到烧粪了。我三步并作两步，过简易桥到对岸，沿着新修的水泥路，朝西向胜蓝桥方向走去，很快就到了烧粪的地方，是胜蓝桥下不远处的河滩上。一中学校前的郁水河已列为风景观光带，两岸的土地早被征用。水泥路及河堤下的河滩处，原是岸上居民
基于STC12C5A60S2单片机的LED汉字显示系统的设计 lantiandianzi 单片机嵌入式硬件
本设计基于单片机的LED汉字显示装置，该设计以STC12C5A60S2单片机为核心，利用最小系统和多个模块完成设计，包括点阵驱动模块、时钟模块、串口通信模块、红外线接收模块以及LED点阵屏。其中，点阵驱动模块采用74HC245芯片设计完成，结合DS1302时钟芯片完成LED点阵显示屏的汉字与时间显示，使用按键、串口、红外线遥控可以完成时间的实时更新、自定义汉字显示、改变汉字显示颜色、改变汉字滚动方
51单片机-AT24C02-实验2-秒表实验（可参考上一节） Whappy001 51单片机嵌入式硬件单片机
利用定时器去对按键和数码管进行扫描(Whappy)main.c#include#include"LCD1602.h"#include"AT24C02.h"#include"Delay.h"#include"Timer0.h"#include"Nixie.h"#include"Key.h"unsignedcharKeyNum;unsignedcharMin,Sec,MiniSec;unsignedc
单片机在医疗设备中的应用实例教程 kkchenjj 单片机单片机嵌入式硬件
单片机在医疗设备中的应用实例教程单片机基础单片机概述单片机，全称为单片微型计算机（Single-ChipMicrocomputer），是一种将中央处理器（CPU）、存储器、输入输出接口等主要计算机部件集成在一块芯片上的微型计算机系统。它具有体积小、功耗低、成本低廉、控制功能强大等特点，广泛应用于工业控制、家用电器、汽车电子、医疗设备等多个领域。特点集成度高：单片机将计算机的主要部件集成在一块芯片上
单片机与传感器接口技术应用实例教程 kkchenjj 单片机单片机 nosql 嵌入式硬件
单片机与传感器接口技术应用实例教程单片机基础单片机概述单片机，全称为单片微型计算机（Single-ChipMicrocomputer），是一种将中央处理器（CPU）、存储器、输入输出接口等主要计算机部件集成在一块芯片上的微型计算机系统。它具有体积小、功耗低、成本低廉、控制功能强大等特点，广泛应用于工业控制、家用电器、汽车电子、通信设备、医疗器械等领域。特点集成度高：单片机将计算机的主要部件集成在一
蓝桥杯第十四届C++C组 bug～bug～蓝桥杯蓝桥杯 c++c语言
目录三国游戏填充翻转【单调队列优化DP】子矩阵【快速幂、欧拉函数】互质数的个数【tire树】异或和之差【质因数分解】公因数匹配子树的大小三国游戏题目描述小蓝正在玩一款游戏。游戏中魏蜀吴三个国家各自拥有一定数量的士兵X,Y,Z(一开始可以认为都为0)。游戏有n个可能会发生的事件，每个事件之间相互独立且最多只会发生一次，当第i个事件发生时会分别让X,Y,Z增加Ai,Bi,Ci。当游戏结束时(所有事件的
【蓝桥杯】2.走出迷宫的最少步数——DFS 电次电次深度优先蓝桥杯算法
1432-【基础】走出迷宫的最少步数题目描述一个迷宫由R行C列格子组成，有的格子里有障碍物，不能走；有的格子是空地，可以走。给定一个迷宫，求从左上角走到右下角最少需要走多少步(数据保证一定能走到)。只能在水平方向或垂直方向走，不能斜着走。输入第一行是两个整数，R和C，代表迷宫的行数和列数。（1usingnamespacestd;intn,m;chara[50][50];//地图intd[50][5
OJ2219左移右移（链表）——蓝桥杯2022年国赛爱干饭的boy 数据结构与算法题目数据结构算法
代码为（双向链表）：#includeusingnamespacestd;structlink{intdata;link*prev;link*next;};intmain(){intn,m;cin>>n>>m;link*l=newlink();//创建头节点，不存储实际数据，仅作为起始点link*tail=l;//尾指针初始指向头节点unordered_maph;//哈希表，用于快速查找任何节点fo
掌握单片机,其实并不难培林将军单片机嵌入式硬件
Fearwillbeyourenemy恐惧将会是你的敌人单片机的学习绝不仅仅是对一项知识的掌握。想要学好单片机，需要从硬件结构、内部资源、外设应用等几个方面多方位入手。而要想成为一名嵌入式工程师，就要对单片机的基础非常熟悉，并且掌握C语言当中各个功能的初始化、启动、停止各类函数的编写调试。那么想要掌握单片机需要从哪几个方面入手呢？数字I/O的应用在大多数的单片机实验中，跑马灯实验正是数字I/O的典
蓝桥杯备赛day01：循环小西yu 蓝桥杯2025备赛蓝桥杯 java python c++
这类题目较为简单，就不写解析了，提供三种语言的参考代码，欢迎在评论区讨论！分离整数的各个位数#includeusingnamespacestd;intmain(){intn;cin>>n;while(n>0){cout0:print(n%10,end='')n=n//10importjava.util.Scanner;publicclassMain{publicstaticvoidmain(Str
无人机动力系统设计之电调芯片参数选型 lida2003 Physics 无人机动力系统 ESC
无人机动力系统设计之电调芯片参数选型1.源由2.关键因素2.1电压范围2.2电流处理能力2.3控制方式2.4PWM输出与分辨率2.5通讯接口2.6保护功能2.7支持霍尔传感器与无传感器模式2.8集成度与外围器件2.9效率与散热2.10市场供应与成本3.因素阐述3.1PWM工作频率3.1.1电机控制芯片3.1.2单片机算法定时器（Timers）电机控制部分3.2单片机工作频率Step1定时器频率St
实现单片机简单的时间片轮询调度盘大海单片机 stm32 51单片机 mcu
时间片轮询调度1.创建一个结构体链表typedefstructtaskMember{pfuntiontaskName;volatileuint32_ttick;uint32_ttaskID;uint32_ttaskStatus;structtaskMember*listNext;}task_t;2.声明一个链表头。statictask_ttaskListHead;task_t*currentTas
单片机程序架构-时间片轮询架构 Jerry--- 嵌入式单片机
1定时器复用说明（1）首先定义任务数、任务定时初值（任务轮询时间=定时初值*定时器中断时间）、任务定时计数器；（2）在定时器中断服务函数中添加【复用函数】。#defineTASK_NUM3//这里定义的任务数为3，表示有三个任务会使用此定时器定时。uint16_tTaskCount[TASK_NUM];//这里为三个任务定义三个变量来存放定时值uint8_tTaskMark[TASK_NUM];/
陕西赛区蓝桥杯 Java b组冲省一每日一敲第二天（苦涩。。 hhXx_琉璃蓝桥杯算法 java
蓝桥杯2023年第十四届省赛真题-数组分割时间限制:3s内存限制:576MB提交:1353解决:279题目描述小蓝有一个长度为N的数组A=[A0,A1,...,AN−1]。现在小蓝想要从A对应的数组下标所构成的集合I={0,1,2,...,N−1}中找出一个子集R1，那么R1在I中的补集为R2。记S1=∑r∈R1Ar，S2=∑r∈R2Ar，我们要求S1和S2均为偶数，请问在这种情况下共有多少种不同
在单片机中，处于高阻态是什么状态 m0_69078052 单片机嵌入式硬件
在单片机（微控制器）中，高阻态（High-Z，HighImpedanceState）是指引脚的电气特性类似于没有连接状态，即该引脚的电流非常小，几乎不对电路产生影响。具体来说，高阻态具有以下几个特点：高阻态的特点输入状态：引脚不驱动任何电平（高电平或低电平），相当于引脚在电路中没有连接。此时，电路中的电流几乎为零。无干扰：高阻态的引脚不会对其他电路产生电气干扰或影响。它在逻辑上“断开”了与电路的连
蓝桥杯1.确定字符串是否包含唯一字符 DANGAOGAO 蓝桥杯 python 蓝桥杯 python
插播一句，博主转学python了，来写写算法题，若掌握好会考虑捐300块。题目：题目描述实现一个算法来识别一个字符串的字符是否是唯一的（忽略字母大小写）。若唯一，则输出YES，否则输出NO。输入描述输入一行字符串，长度不超过100。输出描述输出一行，若字符串的字符是唯一的，则输出YES，否则输出NO。输入输出样例示例输入abd25+输出YESimportosimportsysa=input()a=
蓝桥杯2. 确定字符串是否是另一个的排列 DANGAOGAO 蓝桥杯 python 蓝桥杯 python
题目描述实现一个算法来识别一个字符串str2str2是否是另一个字符串str1str1的排列。排列的解释如下：如果将str1str1的字符拆分开，重新排列后再拼接起来，能够得到str2str2，那么就说字符串str2str2是字符串str1str1的排列。（不忽略大小写）如果str2str2字符串是str1str1字符串的排列，则输出YES；如果str2str2字符串不是str1str1字符串的排
蓝桥杯3. 压缩字符串 DANGAOGAO 蓝桥杯 python 蓝桥杯 python
题目描述实现一个算法来压缩一个字符串。压缩的要求如下：需要判断压缩能不能节省空间，仅在压缩后字符串比原字符串长度更短时进行压缩。压缩的格式是将连续相同字符替换为字符+数字形式，例如"AAABCCDDDD"变为"A3BC2D4"。输入描述输入一行字符串，长度不超过500.输出描述输出一行。若输入的字符串可压缩，则输出压缩后的字符串，否则输出NO。输入输出样例示例输入AAABCCDDDD输出A3BC2
stm32单片机毕业设计方向推荐 Mdc_stdio 单片机
文章目录1前言2如何选题2.1不要给自己挖坑2.2难度把控2.3如何命名题目3单片机嵌入式选题大全3.1嵌入式方向3.2算法方向3.3移动通信方向3.4学长作品展示4最后1前言近期不少学弟学妹询问学长关于单片机和嵌入式相关的毕设选题，学长特意写下这篇文章以作回应！以下是学长亲手整理的物联网相关的毕业设计选题，都是经过学长精心审核的题目，适合作为毕设，难度不高，工作量达标，对毕设有任何疑问都可以问学
通信工程单片机毕设项目选题分享 cnhush 单片机 stm32 毕业设计
文章目录1前言2如何选题2.1不要给自己挖坑2.2难度把控2.3如何命名题目3单片机嵌入式选题大全3.1嵌入式方向3.2算法方向3.3移动通信方向3.4学长作品展示4最后1前言近期不少学弟学妹询问学长关于单片机和嵌入式相关的毕设选题，学长特意写下这篇文章以作回应！以下是学长亲手整理的物联网相关的毕业设计选题，都是经过学长精心审核的题目，适合作为毕设，难度不高，工作量达标，对毕设有任何疑问都可以问学
STM32学习笔记（二、初识stm32单片机）藏，捉单片机 stm32 学习
一、stm32的含义是什么？首先stm32是意法半导体公司（ST）使用ARM公司的Cortex-M为核心生产的32位的单片机。其中，ST---意法半导体公司，即SOC厂商。M---为Microelectronics的缩写，即微型处理器。32---表示控制器为32位的。103---表示F系列的子系列。二、stm32的分类CPU位数内核系列描述32Cortex--M0STM32F0入门级STM32L0
jquery实现的jsonp掉java后台知了ing java jsonp jquery
什么是JSONP？先说说JSONP是怎么产生的：其实网上关于JSONP的讲解有很多，但却千篇一律，而且云里雾里，对于很多刚接触的人来讲理解起来有些困难，小可不才，试着用自己的方式来阐释一下这个问题，看看是否有帮助。 1、一个众所周知的问题，Ajax直接请求普通文件存在跨域无权限访问的问题，甭管你是静态页面、动态网页、web服务、WCF，只要是跨域请求，一律不准； 2、
Struts2学习笔记 caoyong struts2
SSH : Spring + Struts2 + Hibernate 三层架构(表示层,业务逻辑层,数据访问层) MVC模式 (Model View Controller) 分层原则:单向依赖，接口耦合 1、Struts2 = Struts + Webwork 2、搭建struts2开发环境 a>、到www.apac
SpringMVC学习之后台往前台传值方法满城风雨近重阳 springMVC
springMVC控制器往前台传值的方法有以下几种： 1.ModelAndView 通过往ModelAndView中存放viewName：目标地址和attribute参数来实现传参： ModelAndView mv=new ModelAndView(); mv.setViewName="success
WebService存在的必要性？一炮送你回车库 webservice
做Java的经常在选择Webservice框架上徘徊很久，Axis Xfire Axis2 CXF ，他们只有一个功能，发布HTTP服务然后用XML做数据传输。是的，他们就做了两个功能，发布一个http服务让客户端或者浏览器连接，接收xml参数并发送xml结果。当在不同的平台间传输数据时，就需要一个都能解析的数据格式。但是为什么要使用xml呢？不能使json或者其他通用数据
js年份下拉框 3213213333332132 java web ee
<div id="divValue">test...</div>测试 //年份 <select id="year"></select> <script type="text/javascript"> window.onload =
简单链式调用的实现技术归来朝歌方法调用链式反应编程思想
在编程中，我们可以经常遇到这样一种场景：一个实例不断调用它自身的方法，像一条链条一样进行调用这样的调用你可能在Ajax中，在页面中添加标签： $("<p>").append($("<span>").text(list[i].name)).appendTo("#result"); 也可能在HQ
JAVA调用.net 发布的webservice 接口 darkranger webservice
/** * @Title: callInvoke * @Description: TODO(调用接口公共方法) * @param @param url 地址 * @param @param method 方法 * @param @param pama 参数 * @param @return * @param @throws BusinessException
Javascript模糊查找 | 第一章循环不能不重视。 aijuans Way
最近受我的朋友委托用js+HTML做一个像手册一样的程序，里面要有可展开的大纲，模糊查找等功能。我这个人说实在的懒，本来是不愿意的，但想起了父亲以前教我要给朋友搞好关系，再加上这也可以巩固自己的js技术，于是就开始开发这个程序，没想到却出了点小问题，我做的查找只能绝对查找。具体的js代码如下： function search(){ var arr=new Array("my
狼和羊，该怎么抉择 atongyeye 工作
狼和羊，该怎么抉择在做一个链家的小项目，只有我和另外一个同事两个人负责，各负责一部分接口，我的接口写完，并全部测联调试通过。所以工作就剩下一下细枝末节的，工作就轻松很多。每天会帮另一个同事测试一些功能点，协助他完成一些业务型不强的工作。今天早上到公司没多久，领导就在QQ上给我发信息，让我多协助同事测试，让我积极主动些，有点责任心等等，我听了这话，心里面立马凉半截，首先一个领导轻易说
读取android系统的联系人拨号百合不是茶 android sqlite数据库内容提供者系统服务的使用
联系人的姓名和号码是保存在不同的表中,不要一下子把号码查询来,我开始就是把姓名和电话同时查询出来的,导致系统非常的慢关键代码: 1, 使用javabean操作存储读取到的数据 package com.example.bean; /** * * @author Admini
ORACLE自定义异常 bijian1013 数据库自定义异常
实例： CREATE OR REPLACE PROCEDURE test_Exception ( ParameterA IN varchar2, ParameterB IN varchar2, ErrorCode OUT varchar2 --返回值,错误编码 ) AS /*以下是一些变量的定义*/ V1 NUMBER; V2 nvarc
查看端号使用情况征客丶 windows
一、查看端口在windows命令行窗口下执行： >netstat -aon|findstr "8080" 显示结果： TCP 127.0.0.1:80 0.0.0.0:0 &
【Spark二十】运行Spark Streaming的NetworkWordCount实例 bit1129 wordcount
Spark Streaming简介 NetworkWordCount代码 /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with
Struts2 与 SpringMVC的比较 BlueSkator struts2 spring mvc
1. 机制：spring mvc的入口是servlet，而struts2是filter，这样就导致了二者的机制不同。 2. 性能：spring会稍微比struts快。spring mvc是基于方法的设计，而sturts是基于类，每次发一次请求都会实例一个action，每个action都会被注入属性，而spring基于方法，粒度更细，但要小心把握像在servlet控制数据一样。spring
Hibernate在更新时，是可以不用session的update方法的(转帖） BreakingBad Hibernate update
地址：http://blog.csdn.net/plpblue/article/details/9304459 public void synDevNameWithItil() {Session session = null;Transaction tr = null;try{session = HibernateUtil.getSession();tr = session.beginTran
读《研磨设计模式》-代码笔记-观察者模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; import java.util.Observable; import java.util.Observer; /** * “观
重置MySQL密码 chenhbc mysql 重置密码忘记密码
如果你也像我这么健忘，把MySQL的密码搞忘记了，经过下面几个步骤就可以重置了（以Windows为例，Linux/Unix类似）： 1、关闭MySQL服务 2、打开CMD，进入MySQL安装目录的bin目录下，以跳过权限检查的方式启动MySQL mysqld --skip-grant-tables 3、新开一个CMD窗口，进入MySQL mysql -uroot
再谈系统论，控制论和信息论 comsci 设计模式生物能源企业应用领域模型
再谈系统论，控制论和信息论偶然看
oracle moving window size与 AWR retention period关系 daizj oracle
转自： http://tomszrp.itpub.net/post/11835/494147 晚上在做11gR1的一个awrrpt报告时,顺便想调整一下AWR snapshot的保留时间,结果遇到了ORA-13541这样的错误.下面是这个问题的发生和解决过程. SQL> select * from v$version; BANNER -------------------
Python版B树 dieslrae python
话说以前的树都用java写的,最近发现python有点生疏了,于是用python写了个B树实现,B树在索引领域用得还是蛮多了,如果没记错mysql的默认索引好像就是B树... 首先是数据实体对象,很简单,只存放key,value class Entity(object): '''数据实体''' def __init__(self,key,value)
C语言冒泡排序 dcj3sjt126com 算法
代码示例： # include <stdio.h> //冒泡排序 void sort(int * a, int len) { int i, j, t; for (i=0; i<len-1; i++) { for (j=0; j<len-1-i; j++) { if (a[j] > a[j+1]) // >表示升序
自定义导航栏样式 dcj3sjt126com 自定义
-(void)setupAppAppearance { [[UILabel appearance] setFont:[UIFont fontWithName:@"FZLTHK—GBK1-0" size:20]]; [UIButton appearance].titleLabel.font =[UIFont fontWithName:@"FZLTH
11.性能优化-优化-JVM参数总结 frank1234 jvm参数性能优化
1.堆 -Xms --初始堆大小 -Xmx --最大堆大小 -Xmn --新生代大小 -Xss --线程栈大小 -XX:PermSize --永久代初始大小 -XX:MaxPermSize --永久代最大值 -XX:SurvivorRatio --新生代和suvivor比例,默认为8 -XX:TargetSurvivorRatio --survivor可使用
nginx日志分割 for linux HarborChung nginx linux 脚本
nginx日志分割 for linux 默认情况下，nginx是不分割访问日志的，久而久之，网站的日志文件将会越来越大，占用空间不说，如果有问题要查看网站的日志的话，庞大的文件也将很难打开，于是便有了下面的脚本使用方法，先将以下脚本保存为 cutlog.sh，放在/root 目录下，然后给予此脚本执行的权限复制代码代码如下: chmo
Spring4新特性——泛型限定式依赖注入 jinnianshilongnian spring spring4 泛型式依赖注入
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
centOS安装GCC和G++ liuxihope centos gcc
Centos支持yum安装，安装软件一般格式为yum install .......，注意安装时要先成为root用户。按照这个思路，我想安装过程如下：安装gcc：yum install gcc 安装g++： yum install g++ 实际操作过程发现，只能有gcc安装成功，而g++安装失败，提示g++ command not found。上网查了一下，正确安装应该
第13章 Ajax进阶（上） onestopweb Ajax
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
How to determine BusinessObjects service pack and fix pack blueoxygen BO
http://bukhantsov.org/2011/08/how-to-determine-businessobjects-service-pack-and-fix-pack/ The table below is helpful. Reference BOE XI 3.x 12.0.0. y BOE XI 3.0 12.0. x. y BO
Oracle里的自增字段设置 tomcat_oracle oracle
　大家都知道吧，这很坑，尤其是用惯了mysql里的自增字段设置，结果oracle里面没有的。oh，no 　　我用的是12c版本的，它有一个新特性，可以这样设置自增序列，在创建表是，把id设置为自增序列 create table t ( id 　　　　 number generated by default as identity (start with 1 increment b
Spring Security（01）——初体验 yang_winnie spring Security
Spring Security（01）——初体验博客分类： spring Security Spring Security入门安全认证首先我们为Spring Security专门建立一个Spring的配置文件，该文件就专门用来作为Spring Security的配置

51基础入门知识

LED

蜂鸣器与继电器

3共阳数码管静态

4，动态数码管

5.独立按键

6矩阵键盘

7.中断

8.定时器

9.秒表

10.PWM

11.串口通信

12.串口进阶

13.存储映射

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

15.DS18B20

16.DS12302

17.555

18.IIC

你可能感兴趣的:(蓝桥,单片机)