vv啊vv
vv啊vv

基于小蜜蜂老师的进阶与冲刺

一、24C02基础介绍

基于小蜜蜂老师的进阶与冲刺_第1张图片

1.1 AT24C02功能概述

基于小蜜蜂老师的进阶与冲刺_第2张图片

24C02是一个2K Bit的串行EEPROM存储器，内部含有256个字节。在24C02里面有一个8字节的页写缓冲器。该设备的工作电压为1.8V到6.0V，芯片的第7引脚WP为写保护引脚，将该引脚接地允许正常的读写。

1.2 设备地址

基于小蜜蜂老师的进阶与冲刺_第3张图片

同样AT24C02也是IIC通信在IIC总线上一次可以同时挂载8个该设备通过A0 A1 A2来进行设备的选择

设备地址可以分为固定地址和可编程两部分 其中固定地址为1010

可编程地址的A0 A1 A2在该平台默认接的低电平 所以进行写操作时地址为0xa0 进行读操作时地址为0xa1

1.3 读写操作中的应答信号

在写操作中，24C02每接收一个8位字节后会产生一个应答信号。在读操作中，24C02在发送一个8位数据后会释放SDA线并监视应答信号。一旦收到应答信号，将继续发送数据。如果主机没有发送应答信号，从机则停止发送数据且等待一个停止信号。

1.4 字节写操作

24C02接收完设备地址后，产生应答信号；然后接收8位内存字节地址，产生应答信号，接着接收一个8位数据，产生应答信号；最后主机发送停止信号，字节写操作结束

1.5 页写操作

24C02有一个8字节的页写缓冲器，也就是说可以一次连续写入8个字节到缓冲器，然后由缓冲器一次性写到EEPROM。页写操作初始化与字节写操作相同，只是主机不会在写完第一个数据后就发送停止信号，而是在24C02应答后，接着发送7个数据。

需要注意的是，24C02接收到每个数据后，其字节地址的低3位会自动加1，高位地址不变，维持在当前页内。当内部产生的字节地址到达该页边界时，随后的数据将写入该页的页首，先前的写入的数据将会被覆盖

1.6 当前地址读操作

24C02内部的地址寄存器会保存着上次读/写操作最后一个地址加1的值。只要芯片有电，该地址就一直保存着。如果上次读/写操作的地址为N，那么当前地址读操作就从N+1开始。当读到最后一个字节（即255处），地址会回转到0

1.7 字节读操作

主机首先发送起始信号，接着发送设备地址和它想要读取的数据内存字节地址，执行一个伪写操作。在24C02应答主机之后，主机重新发送起始信号和从设备地址，进行读操作。24C02响应并发送应答信号，然后输出所要求的一个8位字节数据。主机接收完这个8位数据后，产生一个“非应答”信号，最后发送停止条件，字节读操作结束。

1.8 连续读操作

在24C02发送完一个8位字节数据之后，主机产生一个应答信号来响应，告知24C02要求读取更多的数据，直到读完最后一个数据，主机向24C02发送一个“非应答”信号，然后发送一个停止信号，结束此操作。

/********************************************
Date:2022-1-14
Author:小殷同学
Learn From:B 站小蜜蜂老师
*********************************************/

#include "reg52.h"
#include "iic.h"

unsigned char dat1 = 0;
unsigned char dat2 = 0; 
unsigned char dat3 = 0;

//共阳数目管段码
//0-f  0xbf代表 -
unsigned char code SMG_Duan[] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,
                                                               0x80,0x90,0x88,0x83,0xC6,0xA1,0x86,0x8E,0xbf};

//---------------------------------简单延时函数-------------------------
void Delay(unsigned int t)
{
     while(t--);
}

//-------------------------------74HC138初始化---------------------------
void Init_74HC138(unsigned char n)
{
     switch(n)
    {
         case 4:P2 = P2| 0x1f; P2 = 0x80; break;
        case 5:P2 = P2| 0x1f; P2 = 0xa0; break;
        case 6:P2 = P2| 0x1f; P2 = 0xc0; break;
        case 7:P2 = P2| 0x1f; P2 = 0xe0; break;
        case 0:P2 = P2| 0X1f; P2 = 0x00; break; //所有锁存器都不选择
    }
}

//----------------------------------系统初始化---------------------------
void InitSystem(void)
{
      Init_74HC138(5);
     P0 = 0x00;             //关闭继电器与蜂鸣器
     Init_74HC138(4);
     P0 = 0xff;   //关闭led
}



//---------------------------------数码管安位显示--------------------------
void SMG_DisplayBit(unsigned char pos ,unsigned char dat)
{
         Init_74HC138(6);
        P0 = 0x01 << pos ;//位选
        Init_74HC138(7);
        P0 = dat;        //段码
}

//-------------------------------关闭所有数码管---------------------------
void SMG_CLOSEALL(unsigned char dat)
{
     Init_74HC138(6);
     P0 = 0xff; //选中所有数码管
     Init_74HC138(7);
     P0 = dat; //关闭
}

//----------------------------时间显示函数----------------------------
void Time_Display(void)
{
     SMG_DisplayBit(0,SMG_Duan[dat1/10]);
     Delay(100);
     SMG_DisplayBit(1,SMG_Duan[dat1%10]);
     Delay(100);
     
     SMG_DisplayBit(2,SMG_Duan[16]);
     Delay(100);
     SMG_DisplayBit(3,SMG_Duan[dat2/10]);
     Delay(100);
     SMG_DisplayBit(4,SMG_Duan[dat2%10]);
     Delay(100);
     SMG_DisplayBit(5,SMG_Duan[16]);
     Delay(100);
     SMG_DisplayBit(6,SMG_Duan[dat3/10]);
     Delay(100);
     SMG_DisplayBit(7,SMG_Duan[dat3%10]);
     Delay(100);
     SMG_CLOSEALL(0xff);
     Delay(100);     
}


//---------------------------------24C02写操作-----------------------------
void Write_24C02(unsigned char addr,unsigned char dat)
{
    IIC_Start();        //IIC总线起始信号                    
    IIC_SendByte(0xa0);     //24C02的写设备地址
    IIC_WaitAck();        //等待从机应答    
    IIC_SendByte(addr);     //内存字节字节
    IIC_WaitAck();         //等待从机应答    
    IIC_SendByte(dat);     //写入目标数据
    IIC_WaitAck();        //等待从机应答    
    IIC_Stop();        //IIC总线停止信号    
}


//---------------------------------24C02读操作-----------------------------
unsigned char Read_24C02(unsigned char addr)
{
    unsigned char temp; //存储读取数据
    IIC_Start();        //IIC总线起始信号                    
    IIC_SendByte(0xa0);     //24C02的写设备地址
    IIC_WaitAck();        //等待从机应答    
    IIC_SendByte(addr);     //内存字节字节
    IIC_WaitAck();         //等待从机应答    
    

    IIC_Start();        //IIC总线起始信号                    
    IIC_SendByte(0xa1);     //24C02的读设备地址
    IIC_WaitAck();        //等待从机应答    
    temp = IIC_RecByte();     //读取数据
    IIC_SendAck(1); //非应答信号
    IIC_Stop();        //IIC总线停止信号        
    return temp;
}


//--------------------------------24C02读写操作--------------------------
void Read_Write_24C02(void)
{
        dat1 =  Read_24C02(0x01);
        dat2 =  Read_24C02(0x03);
        dat3 =  Read_24C02(0x05);

        dat1 += 1;
        dat2 += 1;
        dat3 += 1;
        
        if(dat1 > 10)
        {
             dat1 = 0;
        }
        if(dat2 > 20)
        {
             dat2 = 0;
        }
        if(dat3 > 30)
        {
             dat3 = 0;
        }

     Write_24C02(0x01,dat1);
     Delay(200);
     Write_24C02(0x03,dat2);
     Delay(200);
     Write_24C02(0x05,dat3);
     Delay(200);
}

void main(void)
{
    InitSystem();
    Read_Write_24C02();
     while(1)
    {
        Time_Display();
    }
}

二。智能照明控制器

基于小蜜蜂老师的进阶与冲刺_第4张图片 
#include "reg52.h"
#include "iic.h"


/********************************************
Date:2022-1-15
Author:小殷同学
Learn From:B 站小蜜蜂老师
*********************************************/


//led 灯定义
sbit L1 = P0^0;
sbit L2 = P0^1;
sbit L3 = P0^2;
sbit L4 = P0^3;
sbit L5 = P0^4;
sbit L6 = P0^5;
sbit L7 = P0^6;
sbit L8 = P0^7;

unsigned char Rd1 = 0; //记录光敏实时数值
unsigned char Rd1_old = 0; //记录历史光敏值
unsigned char Level = 0; //记录灯光实时等级
unsigned char Level_old = 0; //记录灯光历史等级

//按键定义
sbit S4 = P3^3;
sbit S5 = P3^2;

//共阳数目管段码
//0-f  0xbf代表 -
unsigned char code SMG_Duan[] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,
                                                               0x80,0x90,0x88,0x83,0xC6,0xA1,0x86,0x8E,0xbf};





//---------------------------------简单延时函数-------------------------
void Delay(unsigned int t)
{
     while(t--);
}

//-------------------------------74HC138初始化---------------------------
void Init_74HC138(unsigned char n)
{
     switch(n)
    {
         case 4:P2 = P2| 0x1f; P2 = 0x80; break;
        case 5:P2 = P2| 0x1f; P2 = 0xa0; break;
        case 6:P2 = P2| 0x1f; P2 = 0xc0; break;
        case 7:P2 = P2| 0x1f; P2 = 0xe0; break;
        case 0:P2 = P2| 0X1f; P2 = 0x00; break; //所有锁存器都不选择
    }
}

//----------------------------------系统初始化---------------------------
void InitSystem(void)
{
      Init_74HC138(5);
     P0 = 0x00;             //关闭继电器与蜂鸣器
     Init_74HC138(4);
     P0 = 0xff;   //关闭led
}



//---------------------------------数码管安位显示--------------------------
void SMG_DisplayBit(unsigned char pos ,unsigned char dat)
{
         Init_74HC138(6);
        P0 = 0x01 << pos ;//位选
        Init_74HC138(7);
        P0 = dat;        //段码
}

//-------------------------------关闭所有数码管---------------------------
void SMG_CLOSEALL(unsigned char dat)
{
     Init_74HC138(6);
     P0 = 0xff; //选中所有数码管
     Init_74HC138(7);
     P0 = dat; //关闭
}

//----------------------------光敏数据读取函数----------------------------
void Read_Rd1_Data()
{
    IIC_Start();          //IIC起始信号
    IIC_SendByte(0x90);     //写入设备地址
    IIC_WaitAck();         //等待应答
    IIC_SendByte(0x01);     //写入通道 AIN1
    IIC_WaitAck();         //等待应答
    IIC_Stop();            //IIC停止信号

    IIC_Start();        //IIC起始信号
    IIC_SendByte(0x91);     //读取设备地址
    IIC_WaitAck();        //等待应答
    Rd1 = IIC_RecByte(); //读取数据
    IIC_SendAck(1);        //非应答
    IIC_Stop();            //IIC停止信号
}

//--------------------------------光敏等级Led控制---------------------------
/*
        等级1：255 <= 光照数据 < 200，L1点亮。

       等级2：200 <= 光照数据 < 150，L1~L2点亮。

       等级3：150 <= 光照数据 < 100，L1~L4点亮。

       等级4：100 <= 光照数据 < 50，L1~L6点亮。

       等级5：50 <= 光照数据 < 0，L1～L8点亮。

*/
void Led_Level_Tackle(void)
{
    Init_74HC138(4);
    Read_Rd1_Data();
    if(Rd1 > 200 && Rd1 <= 250)
    {
      //L1 = 0;
        P0 = 0xfe;
        Level = 5;
    }
    else if(Rd1 > 150 && Rd1 <= 200) 
    {
         //L1 = L2 = 0;
        P0 = 0xfc;
        Level = 4;
    }
    else if(Rd1 > 100 && Rd1 <= 150) 
    {
         //L1 = L2 = L3 = L4 = 0;
        P0 = 0xf0;
        Level = 3;
    }
    else if(Rd1 > 50 && Rd1 <= 100) 
    {
         //L1 = L2 = L3 = L4 = L5 = L6 = 0;
        P0 = 0xc0;
        Level = 2;
    }
    else if(Rd1 > 0 && Rd1 <= 50) 
    {
         //L1 = L2 = L3 = L4 = L5 = L6 = L7 = L8 = 0;
        P0 = 0x00;
        Level = 1;
    }

}

//----------------------------------24c02写操作-----------------------------
void Write_24C02(unsigned char addr,unsigned char dat)
{
        IIC_Start();                    //IIC起始信号
        IIC_SendByte(0xa0);                //发送设备地址 写操作
        IIC_WaitAck();                    //等待应答
        IIC_SendByte(addr);                //发送写单元地址
        IIC_WaitAck();                    //等待应答
        IIC_SendByte(dat);                //发送目标数据
        IIC_WaitAck();                    //等待应答
        IIC_Stop();                        //IIC停止信号
}

//----------------------------------24c02读操作-------------------------------
unsigned char Read_24C02(unsigned char addr)
{
         unsigned  char temp;        //接收数据变量
        IIC_Start();                //IIC起始信号
        IIC_SendByte(0xa0);            //发送设备地址 写操作
        IIC_WaitAck();                //等待应答
        IIC_SendByte(addr);            //发送写单元地址
        IIC_WaitAck();                //等待应答

        IIC_Start();                //IIC起始信号
        IIC_SendByte(0xa1);            //发送设备地址 读操作
        IIC_WaitAck();                //等待应答
        temp = IIC_RecByte();        //接收数据
        IIC_SendAck(1);                //非应答
        IIC_Stop();                    //IIC停止信号
        return temp    ;                //返回数据
}

//----------------------------------数码管数据显示---------------------------
void SMG_Dispaly_New_Data(void)
{
     SMG_DisplayBit(0,SMG_Duan[16]);
     Delay(200);
     SMG_DisplayBit(1,SMG_Duan[Level]);
     Delay(200);
     SMG_DisplayBit(2,SMG_Duan[16]);
     Delay(200);
     SMG_DisplayBit(3,0xff);
     Delay(200);
     SMG_DisplayBit(4,0xff);
     Delay(200);
     SMG_DisplayBit(5,SMG_Duan[Rd1/100]);
     Delay(200);
     SMG_DisplayBit(6,SMG_Duan[Rd1/10%10]);
     Delay(200);
     SMG_DisplayBit(7,SMG_Duan[Rd1%10]);
     Delay(200);
}

//显示旧值
void SMG_Dispaly_Old_Data(void)
{
     SMG_DisplayBit(0,SMG_Duan[16]);
     Delay(200);
     SMG_DisplayBit(1,SMG_Duan[Level_old]);
     Delay(200);
     SMG_DisplayBit(2,SMG_Duan[16]);
     Delay(200);
     SMG_DisplayBit(3,0xff);
     Delay(200);
     SMG_DisplayBit(4,0xff);
     Delay(200);
     SMG_DisplayBit(5,SMG_Duan[Rd1_old/100]);
     Delay(200);
     SMG_DisplayBit(6,SMG_Duan[Rd1_old/10%10]);
     Delay(200);
     SMG_DisplayBit(7,SMG_Duan[Rd1_old%10]);
     Delay(200);
}
//---------------------------------------按键读写操作------------------------
//按下S4按键将当前的灯光控制等级和光敏电阻的数据保存到存储器24C02的0x01和0x02内存单元中。
// 按下S5按键时，读取存储在24C02的历史数据并显示在数码管上，松开S5按键后，恢复显示实时数据。
void Key_Tackle(void)
{
     if(S4 == 0)
     {
            Delay(20);
            if(S4 == 0)
            {
                 Write_24C02(0x01,Level);      //写入灯光等级
                Delay(200);
                Write_24C02(0x02,Rd1);            //写入光敏数值
                while(S4 == 0)
                {
                     SMG_Dispaly_New_Data();     //实时数据显示
                }
            }
     }

     if(S5 == 0)
     {
            Delay(20);
            if(S5 == 0)
            {
                 Level_old = Read_24C02(0x01);     //读取灯光等级
                Delay(200);
                Rd1_old   =  Read_24C02(0x02); //读取光敏数值
                while(S5 == 0)
                {
                    SMG_Dispaly_Old_Data();         //历史数据显示
                }
            }
     }
}
//-------------------------------------主函数----------------------------------
void main(void)
{
    InitSystem();          //系统初始化
     while(1)
    {
        
        Led_Level_Tackle();        //灯光等级获取
        SMG_Dispaly_New_Data();     //数码管实时显示
        Key_Tackle();          //按键切换
    }

}

三。PWM信号控制呼吸流水灯

基于小蜜蜂老师的进阶与冲刺_第5张图片 
#include "regx52.h"
#include "absacc.h"
 
sbit S7 = P3^0;
sbit S4 = P3^3;
 
unsigned char pwm = 0;          
unsigned char pwm_duty = 0;              
unsigned char times = 0;        
unsigned char led_go = 0;       
unsigned char stat_go = 0;      
unsigned char stat = 0;         
unsigned char key_puse = 0;     
 
unsigned char code SMG_duanma[18]=
        {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
         0x88,0x80,0xc6,0xc0,0x86,0x8e,0xbf,0x7f};
 
void DelaySMG(unsigned int t)
{
    while(t--);
}
 
void DisplaySMG_Bit(unsigned char pos, unsigned char value)
{
    XBYTE[0xE000] = 0xff;
    XBYTE[0xC000] = 0x01 << pos;
    XBYTE[0xE000] = value;
}
 
void Display_Info(unsigned char pos, unsigned char duty)
{
    DisplaySMG_Bit(0, SMG_duanma[pos]);
    DelaySMG(500);
 
    DelaySMG(500);
    DisplaySMG_Bit(6, SMG_duanma[duty / 10]);
    DelaySMG(500);
    DisplaySMG_Bit(7, SMG_duanma[duty % 10]);    
    DelaySMG(500);
    
    DisplaySMG_Bit(0, 0xff);
    DisplaySMG_Bit(6, 0xff);
    DisplaySMG_Bit(7, 0xff);
}
 
void Init_Timer0()
{
    TMOD = 0x01;
    TH0 = (65535 - 1000) / 256;            
    TL0 = (65535 - 1000) % 256;
    
    ET0 = 1;
    EA = 1;
    TR0 = 1;
}
 
void Service_Timer0() interrupt 1
{
    TH0 = (65535 - 1000) / 256;
    TL0 = (65535 - 1000) % 256;
    
    if(stat_go == 0)                              
      {
        XBYTE[0x8000] = 0xe7;                        
        return;
      } 
    
        pwm++;                
  
      if(pwm <= pwm_duty)   
      {
    XBYTE[0x8000] = ~(0x01 << stat);       
      }
      else if(pwm <= 10)
      {
        XBYTE[0x8000] = 0xff;
      }
      else
      {
        XBYTE[0x8000] = ~(0x01 << stat);
    
        pwm = 0;
        if(key_puse == 0)     
        {
          times++;
        }
      }
}
 
void LED_Control()
{
  if(times == 5)          
  {
    times = 0;
    if(led_go == 0)       
    {
      pwm_duty = pwm_duty + 1;
      if(pwm_duty == 11)
      {
                pwm_duty = 10;
        led_go = 1;
      }
    }
    else if(led_go == 1)  
    {
      pwm_duty = pwm_duty - 1;
      if(pwm_duty == 255)
      {
                pwm_duty = 0;
        led_go = 0;
        
        if(stat_go == 1)      
        {
          stat++;
          if(stat == 8)
          {
            stat = 0;
          }
        }
        else if(stat_go == 2) 
        {
          stat--;
          if(stat == 255)
          {
            stat = 7;
          }
        }
      }
    }
  }
}
 
void Scan_Keys()
{
    if(S4 == 0)
    {
        DelaySMG(100);
        if(S4 == 0)
        {
            while(S4 == 0)
            {
                key_puse = 1;
            }
            key_puse = 0;
            
      stat_go++;            
      if(stat_go == 3)
      {
        stat_go = 1;
      }
        }
    }
    
    if(S7 == 0)
    {
        DelaySMG(100);
        if(S7 == 0)
        {
            while(S7 == 0)
            {
                key_puse = 1;
                Display_Info(stat + 1, pwm_duty * 10);
            }
            key_puse = 0;
        }
    }
}
 
void Init_System()
{
    XBYTE[0xA000] = 0xff;
    XBYTE[0xA000] = 0x00;
    XBYTE[0xE000] = 0xff;
    XBYTE[0xC000] = 0xff;
    
    Init_Timer0();
}
 
void main()
{
    Init_System();
    while(1)
    {
        LED_Control();
        Scan_Keys();
    }
}

四。超声波测距

基于小蜜蜂老师的进阶与冲刺_第6张图片 
#include "reg52.h"
#include "intrins.h"

/********************************************
Date:2022-1-19
Author:小殷同学
Base Learn From:B 站小蜜蜂老师
*********************************************/

sbit TX = P1^0;
sbit RX = P1^1;
unsigned int Time = 0;
unsigned int dis = 0;
#define somenop() {_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();}
//共阳数目管段码
unsigned char month = 0;     //定义一个变量让其变化显示
//0-f  0xbf代表 -
unsigned char code SMG_Duan[] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,
                                                               0x80,0x90,0x88,0x83,0xC6,0xA1,0x86,0x8E,0xbf};


//---------------------------------简单延时函数-------------------------
void delay(unsigned int t)
{
     while(t--);
}


void Delay12us()                  //@12.000MHz 延时12us
{
    unsigned char i;
 
    _nop_();
    _nop_();
    i = 33;
    while (--i);
}

//-------------------------------74HC138初始化---------------------------
void Init_74HC138(unsigned char n)
{
     switch(n)
    {
         case 4:P2 = P2| 0x1f; P2 = 0x80; break;
        case 5:P2 = P2| 0x1f; P2 = 0xa0; break;
        case 6:P2 = P2| 0x1f; P2 = 0xc0; break;
        case 7:P2 = P2| 0x1f; P2 = 0xe0; break;
        case 0:P2 = P2| 0X1f; P2 = 0x00; break; //所有锁存器都不选择
    }
}

//----------------------------------系统初始化---------------------------
void InitSystem(void)
{
      Init_74HC138(5);
     P0 = 0x00;             //关闭继电器与蜂鸣器
     Init_74HC138(4);
     P0 = 0xff;   //关闭led
}



//---------------------------------数码管安位显示--------------------------
void SMG_DisplayBit(unsigned char pos ,unsigned char dat)
{
         Init_74HC138(6);
        P0 = 0x01 << pos ;//位选
        Init_74HC138(7);
        P0 = dat;        //段码
}


//-------------------------------关闭所有数码管----------------------
void SMG_CLOSEALL(unsigned char dat)
{
     Init_74HC138(6);
     P0 = 0xff; //选中所有数码管
     Init_74HC138(7);
     P0 = dat; //关闭
}

void SMG_Display_Dynamic(void)
{
        SMG_DisplayBit(0,0xff);
        delay(200);
        SMG_DisplayBit(1,0xff);
        delay(200);
        SMG_DisplayBit(2,0xff);
        delay(200);
        SMG_DisplayBit(3,0xff);
        delay(200);
        SMG_DisplayBit(4,0xff);
        delay(200);
        SMG_DisplayBit(5,SMG_Duan[dis/100]);
        delay(200);
        SMG_DisplayBit(6,SMG_Duan[dis/10%10]);
        delay(200);
        SMG_DisplayBit(7,SMG_Duan[dis%10]);
        delay(200);
        SMG_CLOSEALL();
        delay(200);
}


//--------------------------------------发出声波----------------------------------
void SendWave(void)
{
    unsigned char i;
    for(i = 0; i < 8;i++)
    {
        TX = 1;
        somenop();
        TX = 0;
         somenop();     
    }
}
//------------------------------------超声波测距----------------------------------
void Ultrasonic_Dis(void)
{
    TMOD &= 0x0f; //定时器1模式0 13位最大值8192
    TH1 = 0x00;
    TL1 = 0x00;
    TF1  = 0; //溢出标志位
    TR1 = 0;
    SendWave();     //发送声波信号
    TR1 = 1;//启动定时
    while(RX == 1 && TF1 == 0);    //等待超声波信号返回或者等到测量超出范围  返回RX = 0
    TR1 = 0;//停止计时
    if(TF1 == 1) //溢出了还没有返回信号
    {
         TF1 = 0;
        dis = 999;
    }
    else
    {
          //接收到了返回信号 将定时时间合成16位
         Time = (TH1 << 8) | TL1; //总时间
         //dis = ((Time / 10) * 17) / 100 + 3;
         dis = Time * 0.0172;    
    }
}
//------------------------------------------------------------------------------------
void Delay_SMG(    unsigned char t)
{
     while(t--)
    {
        SMG_Display_Dynamic();
    }
}


void main(void)
{
    InitSystem();
     while(1)
    {
         Ultrasonic_Dis();
         Delay_SMG(50);
    }
}

五，模拟冲刺1

基于小蜜蜂老师的进阶与冲刺_第7张图片 
#include "reg52.h"
#include "iic.h"


/*****************************************************
*第十三届省赛模拟
*Date:2022-3-27
*Author:小殷
*****************************************************/


//独立按键定义
sbit S7 = P3^0;
sbit S6 = P3^1;
sbit S5 = P3^2;
sbit S4 = P3^3;

//LED定义
sbit LED1 = P0^0;
sbit LED2 = P0^1;
sbit LED3 = P0^2;
sbit LED4 = P0^3;
sbit LED5 = P0^4;

unsigned int Frequent = 0 ,f_data = 0,count = 0,count_flag = 0;   //频率相关变量
unsigned int Period = 0;    //周期
unsigned int Voltage_Rd1 = 0,Voltage_Rb2 = 0,Voltage = 0; //电压
unsigned int old_voltage  = 0,old_frequent = 0;
unsigned char led_flag = 0; //0 代表开启  1 代表关闭
unsigned char channel = 1,interface = 1 ; //通道编号  和显示界面
unsigned char time_flag = 0; //1s标志
unsigned char s7_press = 0,s_count = 0,s7_mode = 0; //按键长按下标志  ，计时变量  模式切换
unsigned char code smg_data[] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0xbf,0xff};
unsigned char code smg_data_dot[] = {0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10};
unsigned char led[] = {0xfe,0xfd,0xfb,0xf7,0xef,0xff,0xff,0xff}; //led


void SMG_Display_V(void);
void SMG_Display_F(void);
void SMG_Display_T(void);

/**********************简单延时**********************/
void delay(unsigned char t)
{
     while(t--);
}


void delay_smg(unsigned char t)
{
     while(t--)
    {
         if(interface == 1)
        {
             SMG_Display_F();
        }
        else if(interface == 2)
        {
                SMG_Display_T();
        }
        else if(interface == 3)
        {
             SMG_Display_V();
        }

    }
}


/**********************锁存器操作********************/
void Init_74HC138(unsigned char 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;
        case 0:P2 = (P2 & 0x1f) | 0x00;break;
    }
}

/*********************数码管安位操作*******************/
void SMG_DisplayBit(unsigned char pos,unsigned char dat)
{
     Init_74HC138(6);
    P0 = (0x01 << pos);
    Init_74HC138(7);
    P0 = dat;
    Init_74HC138(0);
}

/*************************关闭所有数码管***************/
void SMG_Close(void)
{
    Init_74HC138(6);
    P0 = 0xff;
    Init_74HC138(7);
    P0 = 0xff;
    Init_74HC138(0);
}    

/**********************系统初始化**********************/
void Init_System(void)
{
     Init_74HC138(4);
    P0 = 0xff;
    Init_74HC138(5);
    P0 = 0x00;
    Init_74HC138(0);
}

/***********************数码管功能显示******************/
void SMG_Display_F(void)
{
     SMG_DisplayBit(0,0x8e);  // F ->0111 0001 0x8e
    delay(200);
    if(Frequent > 999999)
    {
        SMG_DisplayBit(1,smg_data[Frequent/1000000]);
      delay(200);
    }
 if(Frequent > 99999)
    {
        SMG_DisplayBit(2,smg_data[Frequent/100000%10]);
     delay(200);
    }
     if(Frequent > 9999)
    {
        SMG_DisplayBit(3,smg_data[Frequent/10000%10]);
        delay(200);
    }
 if(Frequent > 999)
    {
        SMG_DisplayBit(4,smg_data[Frequent/1000%10]);
      delay(200);
    }
 if(Frequent > 99)
    {
         SMG_DisplayBit(5,smg_data[Frequent /100%10]);
         delay(200);
    }
 if(Frequent > 9)
    {
        SMG_DisplayBit(6,smg_data[Frequent /10%10]);
        delay(200);
    }

    SMG_DisplayBit(7,smg_data[Frequent %10]);
    delay(200);
    SMG_Close();

}

/*****************************周期显示***********************/
void SMG_Display_T(void)
{
    Period = 1.0/Frequent *1000000;
    SMG_DisplayBit(0,0xc8);  // >0001 0011  0xc8
    delay(200);
    if(Period > 999999)
    {
        SMG_DisplayBit(1,smg_data[Period/1000000]);
      delay(200);
    }
 if(Period > 99999)
    {
        SMG_DisplayBit(2,smg_data[Period/100000%10]);
     delay(200);
    }
     if(Period > 9999)
    {
        SMG_DisplayBit(3,smg_data[Period/10000%10]);
        delay(200);
    }
 if(Period > 999)
    {
        SMG_DisplayBit(4,smg_data[Period/1000%10]);
      delay(200);
    }
 if(Period > 99)
    {
         SMG_DisplayBit(5,smg_data[Period /100%10]);
         delay(200);
    }
 if(Period > 9)
    {
        SMG_DisplayBit(6,smg_data[Period /10%10]);
        delay(200);
    }

    SMG_DisplayBit(7,smg_data[Period %10]);
    delay(200);
    SMG_Close();
    
}

/*******************************电压显示**********************/
void SMG_Display_V(void)
{
    SMG_DisplayBit(0,0xc1);  // >1000 0011  0xc8
    delay(200);
    SMG_DisplayBit(1,0xbf); // -  
    delay(200);
    SMG_DisplayBit(2,smg_data[channel]);  
    delay(200);
    SMG_DisplayBit(3,0xff);  
    delay(200);
    SMG_DisplayBit(4,0xff);  
    delay(200);
    SMG_DisplayBit(5,smg_data_dot[Voltage/100]);  
    delay(200);
    SMG_DisplayBit(6,smg_data[Voltage/10%10]);  
    delay(200);
    SMG_DisplayBit(7,smg_data[Voltage%10]);  
    delay(200);
    SMG_Close();
    delay(200);
}
/******************************定时器初始化******************/
void Init_Timer(void)
{
     TMOD = 0x16; //定时器0计数 定时器1 计时
    TH0 = 0xff;
    TL0 = 0xff;
    TH1 = (65535-50000)/256; //50ms
    TL1 = (65535-50000)%256;
    ET0 = 1;
    ET1 = 1;
    TR0 = 1;
    TR1 = 1;
    EA  = 1;
}




unsigned char  Read_RD1(void)
{
     unsigned char temp  = 0;
     IIC_Start();
     IIC_SendByte(0x90);
     IIC_WaitAck();
     IIC_SendByte(0x01);   //光敏通道
     IIC_WaitAck();
     IIC_Stop(); 
     
     IIC_Start();
     IIC_SendByte(0x91);
     IIC_WaitAck();
     temp = IIC_RecByte();
     IIC_SendAck(1);
     IIC_Stop(); 
     return temp;
}



unsigned char  Read_RD2(void)
{
     unsigned char temp  = 0;
     IIC_Start();
     IIC_SendByte(0x90);
     IIC_WaitAck();
     IIC_SendByte(0x03);   //电位器通道
     IIC_WaitAck();
     IIC_Stop(); 
     
     IIC_Start();
     IIC_SendByte(0x91);
     IIC_WaitAck();
     temp = IIC_RecByte();
     IIC_SendAck(1);
     IIC_Stop(); 
     return temp;
}

/***************************按键处理*************************/
void KeyScans(void)
{
     if(S4 == 0)
    {
         delay_smg(20);
        if(S4 == 0)
        {
             while(S4 == 0); //等待按键松开
            if(interface == 1)
            {
                 interface = 2;
                SMG_Display_F();
            }
            else if(interface == 2)
            {
                 interface = 3;
                SMG_Display_T();
            }
            else if(interface == 3)
            {
                 interface = 1;
                SMG_Display_V();
            }
        }
    }

    if(S5 == 0)
    {
         delay_smg(20);
        if(S5 == 0)
        {
             while(S5 == 0); //等待按键松开
            if(channel == 1)
            {
                 channel = 3;
            }
            else if(channel == 3)
            {
                channel = 1;
            }
        }
    }

    if(S6 == 0)
    {
         delay_smg(20);
        if(S6 == 0)
        {
             while(S6 == 0); //等待按键松开
            old_voltage = Voltage ;         //保存旧值
        }
    }

    if(S7 == 0)
    {
         delay_smg(20);
        if(S7 == 0)
        {
            s7_press = 0;   //按键按下标志
            s_count = 0;
            while(S7 == 0); //等待按键松开
            if(s7_press == 1)       //长按
            {
                if(s7_mode == 0)    //模式切换变量 第一次长按关闭Led功能  再次长按打开led功能
                {
                     s7_mode = 1;
                    led_flag = 1;     //关闭led功能
                }
                else if(s7_mode == 1)
                {
                     s7_mode = 0;
                    led_flag = 0;        //打开led功能
                }    
            }
            else      //短按
            {
            old_frequent = Frequent;     //保存旧值
            }
        }
        

    }

}

/************************Led操作函数*************************/
void Led_Running(void)
{
     if(led_flag == 0)
    {    
        Init_74HC138(4); //选通Y4 进行LED 控制
        //通道3的实时电压数据大于缓存电压数据，指示灯L1点亮，否则熄灭
        if(Voltage > old_voltage )
        {
             //P0 = led[0];
            LED1 = 0;
        }
        else
        {
             LED1 = 1;
        }
        //实时频率值大于缓存频率数据，指示灯L2点亮，否则熄灭
         if(Frequent > old_frequent )
        {
            //P0 = led[1];
            LED2 = 0;    
        }
        else
        {
             LED2 = 1;
        }
         //处于频率界面，指示灯L3点亮，否则熄灭
        if(interface == 1)
        {
             //P0 = led[2];
            LED3 = 0;
        }
        else
        {
             LED3 = 1;
        }
        //处于周期界面，指示灯L4点亮，否则熄灭。
        if(interface == 2)
        {
             //P0 = led[3];
            LED4 = 0;
        }
        else
        {
             LED4 = 1;
        }
        //处于电压界面，指示灯L5点亮，否则熄灭
         if(interface == 3)
        {
             //P0 = led[4];
            LED5 = 0;
        }
        else
        {
             LED5 = 1;
        }
    }
    else if(led_flag == 1)
    {
        P0 = 0xff;
         Init_74HC138(4);    
    }
    //Init_74HC138(0);
}
/****************************主函数**************************/
void main(void)
{
     Init_System();
    Init_Timer();
    while(1)
    {
        KeyScans();
        switch(interface)
        {
             case 1:SMG_Display_F();break;
            case 2:SMG_Display_T();break;
            case 3:SMG_Display_V();break;
        }
         if(interface == 3)
        {
            switch(channel)
            {
              case 1: Voltage_Rd1 = Read_RD1();
                              Voltage = ( Voltage_Rd1/255.0 *5*100);//将其扩大100倍方便显示
                                break;
                case 3:    Voltage_Rb2 = Read_RD2();
                              Voltage = ( Voltage_Rb2/255.0 *5*100);//将其扩大100倍方便显示
                        break;
            }
        }

        Led_Running();

    }

}

void Server_Timer0() interrupt 1
{
     f_data++; 
}


void Server_Timer1() interrupt 3
{
    TH1 = (65535-50000)/256; //50ms
    TL1 = (65535-50000)%256;
    count++;
    s_count++;
    if(count == 20) //1s
    {
         Frequent = f_data;
        f_data = 0;
        count = 0;
    }

    //长按计时
    if(s_count == 20)
    {
         s7_press = 1;     //到达1s  s7press 置1
    }

}
基于小蜜蜂老师的进阶与冲刺_第8张图片 
#include "reg52.h"
#include "iic.h"

/**************************************
*第十三届蓝桥杯单片机省赛模拟
*Date:2022-3-29
*Author:小殷
***************************************/

sfr P4 = 0xc0;
sbit H1 = P3^0;
sbit H2 = P3^1;
sbit H3 = P3^2;
sbit H4 = P3^3;

sbit L1 = P3^4;
sbit L2 = P3^5;
sbit L3 = P4^2;
sbit L4 = P4^4;


sbit  LED1 = P0^0;
sbit  LED2 = P0^1;

unsigned char s_press = 0,s_count = 0; //按键按下标志位和计时
unsigned char count = 0,led_flag = 0;    //计时  led标志位
unsigned int count_value = 0,count_value2 = 0;//按键值 和保存值
unsigned char interface = 1;    //界面
//数码管段码
unsigned char code smg_data[] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,
                                                                    0x82,0xF8,0x80,0x90,0xbf,0xff};


//1简单延时
void delay(unsigned int t)
{
     while(t--);
}

//操作锁存器
void Init_74HC138(unsigned char channel)
{
     switch(channel)
    {
         case 4:P2 = (P2 & 0x1f) | 0x80;break; //Y4
        case 5:P2 = (P2 & 0x1f) | 0xa0;break; //Y5
        case 6:P2 = (P2 & 0x1f) | 0xc0;break; //Y6
        case 7:P2 = (P2 & 0x1f) | 0xe0;break; //Y7
        case 0:P2 = (P2 & 0x1f) | 0x00;break; //不选通任何一个
    }
        P2 = (P2 & 0x1f) | 0x00;
}

//数码管安位操作
void SMG_DisplayBit(unsigned char pos,unsigned char dat)
{
     P0 = (0x01 << pos);
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}

//操作所有数码管
void SMG_All(unsigned char dat)
{
     P0 = 0xff;
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}


//显示数码管数据 累加和减的数据
void SMG_Display_Data1(void)
{
 //0001 0001  ->0x88
     SMG_DisplayBit(0,0x88);
    delay(200);
    //    SMG_DisplayBit(0,0xff);
    SMG_DisplayBit(1,0xff);
    delay(200);
    SMG_DisplayBit(2,0xff);
    delay(200);
    SMG_DisplayBit(3,0xff);
    delay(200);
    SMG_DisplayBit(4,0xff);
    delay(200);
    //3位数码管来显示键值
    if(count_value > 99)
    {
        SMG_DisplayBit(5,smg_data[count_value/100]);
         delay(200);
    }
    if(count_value > 9)
    {
            SMG_DisplayBit(6,smg_data[count_value/10%10]);
            delay(200);
    }
    
    SMG_DisplayBit(7,smg_data[count_value%10]);
    delay(200);
    SMG_All(0xff);
    delay(200);
}


//系统初始化
void Init_System(void)
{
     P0 = 0xff;
    Init_74HC138(4);
    P0 = 0x00;
    Init_74HC138(5);
    SMG_All(0xff);
}

//回显数据显示
void SMG_Display_Data2(void)
{
 //1001 0001 ->0x89
     SMG_DisplayBit(0,0x89);
    delay(200);
    //    SMG_DisplayBit(0,0xff);
    SMG_DisplayBit(1,0xff);
    delay(200);
    SMG_DisplayBit(2,0xff);
    delay(200);
    SMG_DisplayBit(3,0xff);
    delay(200);
    SMG_DisplayBit(4,0xff);
    delay(200);
    //3位数码管来显示键值
    if(count_value > 99)
    {
        SMG_DisplayBit(5,smg_data[count_value2/100]);
         delay(200);
    }
    if(count_value > 9)
    {
            SMG_DisplayBit(6,smg_data[count_value2/10%10]);
            delay(200);
    }
    
    SMG_DisplayBit(7,smg_data[count_value2%10]);
    delay(200);
    SMG_All(0xff);
    delay(200);
}


//EEPROM写操作
void Write_AT24C02(unsigned char addr,unsigned char dat)
{
     IIC_Start();
    IIC_SendByte(0xa0);
    IIC_WaitAck();
    IIC_SendByte(addr);
    IIC_WaitAck();
    IIC_SendByte(dat);
    IIC_WaitAck();
    IIC_Stop();
}

//读操作
unsigned char Read_AT24C02(unsigned char addr)
{
     unsigned int temp = 0;
    IIC_Start();
    IIC_SendByte(0xa0);
    IIC_WaitAck();
    IIC_SendByte(addr);
    IIC_WaitAck();

    IIC_Start();
    IIC_SendByte(0xa1);
    IIC_WaitAck();
    temp = IIC_RecByte();
    IIC_SendAck(1);
    IIC_Stop();
    return temp;
}


void Key_Scan(void)
{
    H3 = 0;
    H1 = H2 = H4 = 1;
    L1 =  L2 = L3 = L4 = 1;
    //S9        回显
    if(L3 == 0)
    {
         delay(20);
        if(L3 == 0)
        {
             while(L3 == 0){
            if(interface == 1)
            {
                 interface = 2; //界面切换
                SMG_Display_Data1();    
            }
            else if(interface == 2)
            {
                 interface = 1;
                SMG_Display_Data2();
            }
        }
        }
    }
    //S5 减
    else if(L4 == 0)
    {
         delay(20);
        if(L4 == 0)
        {
            
             while(L4 == 0)     
            {
                SMG_Display_Data1();
            }
             //在计数界面下进行键值的减
            if(interface == 1)
            {
                    count_value--;
            }
        
        }
    }

    H4 = 0;
    H1 = H2 = H3 = 1;
    L1 =  L2 = L3 = L4 = 1;
    //S8    存储
    if(L3 == 0)
    {
         delay(20);
        if(L3 == 0)
        {
            //每次按下时将计时和标志位清零
            s_press = 0;
            s_count = 0;
             while(L3 == 0)    
            {
                    SMG_Display_Data1();
            }    
            if(s_press == 1)     //长按标志
            {
                 count_value = 0;            //计数清零
            }
            //短按
            else
            {
                if(interface == 1)
                {
                     //count_value2 = count_value;        //保存当前值
                    Write_AT24C02(0x00,count_value);
                }
            }
        
        }
    }
    //S4  加
    else if(L4 == 0)
    {
         delay(20);
        if(L4 == 0)
        {        
            
                 while(L4 == 0)
                {
                     SMG_Display_Data1();
                }
                //在计数界面下 进行键值的累加
                if(interface == 1)
                {
                    count_value++;
                }
        }
    }

}


//dac数据
void Read_DAC(float dat)
{
     IIC_Start();
    IIC_SendByte(0x90);
    IIC_WaitAck();
    IIC_SendByte(0x43);
    IIC_WaitAck();
    IIC_SendByte(dat);
    IIC_WaitAck();
    IIC_Stop();
}




//电压显示
void Voltage_Tackle(void)
{
     //为5非0 整数倍     DAC->4  ELSE DAC ->1
    if((count_value % 5)== 0)
    {
         Read_DAC(204); //数字转模拟      0-5  ->0-255
        //5/255 = 4/x    4x51 = 204
    }
    else
    {
         Read_DAC(51);
    }
}

void Led_Tackle(void)
{
    if(interface == 1)
    {
         LED1 = 0;
    }
    else
    {
         LED1 = 1;
    }
    if(count_value > count_value2)
    {
             if(led_flag == 0)
            {
                 LED2 = 0;
            }
            else if(led_flag == 1)
            {
                 LED2 = 1;
            }
    }
    Init_74HC138(4);
}


void Init_Timer(void)
{
     TMOD = 0x01;
    TH0 = (65535-50000)/256;         //50ms
    TL0 = (65535-50000)%256;
    ET0 = 1;
    TR0 = 1;
    EA  = 1;
}
//主函数
void main(void)
{
    Init_System();
    Init_Timer();
    while(1)
    {
        Key_Scan();
         switch(interface)
        {
             case 1:SMG_Display_Data1();break;
            case 2:
                        count_value2 = Read_AT24C02(0x00);
                        SMG_Display_Data2();break;
        }
        Led_Tackle();
        Voltage_Tackle();
        
    }
}


void Server_Timer0() interrupt 1
{
     TH0 = (65535-50000)/256;         //50ms
    TL0 = (65535-50000)%256;
    count++;
    s_count++;
    if(count == 4) //0.2s 开启led标志位
    {
        count = 0;
         if(led_flag == 0)
        {
             led_flag = 1;
        }
        else if(led_flag == 1)
        {
             led_flag = 0;
        }
    }

    if(s_count == 40) //定时2s
    {
         s_press = 1; //长按标志位置1 代表已进入长按模式
    } 

}

六，巩固练习

一、灯闪烁与数码管计数

基于小蜜蜂老师的进阶与冲刺_第9张图片 
#include "reg52.h"


sbit LED1 = P0^0;
sbit LED2 = P0^1;
sbit LED8 = P0^7;
unsigned char led_stat = 0xff;
unsigned char value1 = 0,value2 = 0;
unsigned char code smg_data[] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8, 0x80,0x90};


void SMG_Display_Data(void);//1.简单延时

void delay(unsigned int t)
{
     while(t--);
}


void Delay_s(unsigned int t)
{
  while(t--)
  {
    SMG_Display_Data();                //在延时期间保持数码管刷新
  }
}
//2.锁存器初始化
void Init_74HC138(unsigned char channel)
{
     switch(channel)
    {
         case 4:P2 = (P2 & 0x1f) | 0x80;break;//Y4输出0，LED控制
        case 5:P2 = (P2 & 0x1f) | 0xa0;break;//Y5输出0，蜂鸣器和继电器控制
        case 6:P2 = (P2 & 0x1f) | 0xc0;break; //Y6输出0，数码管位选
        case 7:P2 = (P2 & 0x1f) | 0xe0;break;//Y7输出0，数码管段码
        case 0:P2 = (P2 & 0x1f) | 0x00;break;//所有锁存器不选择
    }
        P2 = (P2 & 0x1f) | 0x00;//所有锁存器不选择
}

//3.数码管安位操作
void SMG_DisplayBit(unsigned char pos,unsigned char dat)
{
     P0 = (0x01 << pos); //数码管的段位
    Init_74HC138(6);
    P0 = dat;           //数码管显示内容
    Init_74HC138(7);
}

//4.操作所有数码管
void SMG_All(unsigned char dat)
{
     P0 = 0xff;        //数码管的段位
    Init_74HC138(6);
    P0 = dat;         //数码管显示内容
    Init_74HC138(7);
}

//5.系统初始化
void Init_System(void)
{
     P0 = 0xff;      //关闭所有led
    Init_74HC138(4);
    P0 = 0x00;     //关闭蜂鸣器和继电器
    Init_74HC138(5);
    SMG_All(0xff); //关闭所有数码管
}

//6.数码管数据显示
void SMG_Display_Data(void)
{
    SMG_DisplayBit(0,smg_data[value1]);
    delay(200);
    SMG_DisplayBit(1,0xff);
    delay(200);
    SMG_DisplayBit(2,0xff);
    delay(200);
    SMG_DisplayBit(3,0xff);
    delay(200);
    SMG_DisplayBit(4,0xff);
    delay(200);
    SMG_DisplayBit(5,0xff);
    delay(200);
    SMG_DisplayBit(6,smg_data[value2/10]);
    delay(200);
    SMG_DisplayBit(7,smg_data[value2%10]);
    delay(200);
    SMG_All(0xff);
    delay(200);    
}


//7.led操作
void Led_Tackle(void)
{
     led_stat &= ~0x80;  //led8电亮
    P0 = led_stat;
    Init_74HC138(4);
    Delay_s(200);

    led_stat |= 0x80;   //熄灭
    P0 = led_stat;
    Init_74HC138(4);
    Delay_s(200);

    value2++;
    if(value2 == 100)
    {
         value2 = 0;
    }

    //led1 和led2 灯同时翻转
    if((led_stat & 0x03) == 0x03)
    {
         led_stat &= ~0x03;
    }
    else
    {
         led_stat |= 0x03;
    }
    P0 = led_stat;
    Init_74HC138(4);
    value1++;
    if(value1 > 9)
    {
         value1 = 0;
    } 
}

void main(void)
{
    Init_System();
    while(1)
    {
        Led_Tackle();
        SMG_Display_Data();     
    }
}

二、24C02基本读写操作

基于小蜜蜂老师的进阶与冲刺_第10张图片 
#include "reg52.h"
#include "iic.h"

unsigned char dat1,dat2,dat3;
unsigned char code smg_data[] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8, 0x80,0x90};

//1.简单延时
void delay(unsigned int t)
{
     while(t--);
}

//2.锁存器操作
void Init_74HC138(unsigned char 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;
        case 0:P2 = (P2 & 0x1f) | 0x00;break;
    }
    P2 = (P2 & 0x1f) | 0x00;
}

//3.数码管安位操作
void SMG_DisplayBit(unsigned char pos,unsigned char dat)
{
    P0 = (0x01 << pos);
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}

//关闭所有数码管
void SMG_Close(void)
{
     P0 = 0xff;
    Init_74HC138(6);
    P0 = 0xff;
    Init_74HC138(7);
}

//4.系统初始化
void Init_System(void)
{
    Init_74HC138(0);
     P0 = 0x00;
    Init_74HC138(5);
    P0 = 0xff;
    Init_74HC138(4);
}

//5.数码管数据显示
void SMG_Display_Data(void)
{
     SMG_DisplayBit(0,smg_data[dat1/10]);
    delay(200);
    SMG_DisplayBit(1,smg_data[dat1%10]);
    delay(200);
    SMG_DisplayBit(2,0xbf);
    delay(200);
    SMG_DisplayBit(3,smg_data[dat2/10]);
    delay(200);
    SMG_DisplayBit(4,smg_data[dat2%10]);
    delay(200);
    SMG_DisplayBit(5,0xbf);
    delay(200);
    SMG_DisplayBit(6,smg_data[dat3/10]);
    delay(200);
    SMG_DisplayBit(7,smg_data[dat3%10]);
    delay(200);
    SMG_Close();
    delay(200);
}


//6.at24c02数据写
void AT24C02_Write(unsigned char addr,unsigned char dat)
{    
    IIC_Start();         //起始信号
    IIC_SendByte(0xa0);  //EEPROM的写设备地址
    IIC_WaitAck();       //等待从机应答
    IIC_SendByte(addr);  //内存单元地址
    IIC_WaitAck();      //等待从机应答
    IIC_SendByte(dat);   //内存写入数据
    IIC_WaitAck();      //等待从机应答
    IIC_Stop();       //停止信号
}

//7.at24c02数据读
unsigned char AT24C02_Read(unsigned char addr)
{
      unsigned char tmp = 0;
      //首先，进行一个伪写操作
      IIC_Start();          //起始信号
      IIC_SendByte(0xa0);    //EEPROM的写设备地址
      IIC_WaitAck();        //等待从机应答
      IIC_SendByte(addr);    //内存单元地址
      IIC_WaitAck();        //等待从机应答
      //然后，开始字节读操作
      IIC_Start();          //起始信号
      IIC_SendByte(0xa1);    //EEPROM的读设备地址
      IIC_WaitAck();        //等待从机应答
      tmp = IIC_RecByte();  //读取内存中的数据
      IIC_SendAck(1);        //产生非应答信号
      IIC_Stop();            //停止信号
      return tmp;
}

//8.数据处理
void Read_Write_Data(void)
{
     //先读取数据
    dat1 =     AT24C02_Read(0x01);
    dat2 =  AT24C02_Read(0x03);
    dat3 =     AT24C02_Read(0x05);


    dat1  = dat1 +1;
    dat2  = dat2 +2;
    dat3  = dat3 + 3 ;
    if( dat1 > 10)
    {
         dat1 = 0;
    }
    if(dat2  > 20)
    {
         dat2 = 0;
    }
    if(dat3  > 30)
    {
         dat3 = 0;
    }

    //将数据写回去
    AT24C02_Write(0x01,dat1);
    delay(1000);
    AT24C02_Write(0x03,dat2);
    delay(1000);
    AT24C02_Write(0x05,dat3);
    delay(1000);

}
void main(void)
{
     Init_System();
    Read_Write_Data();
    while(1)
    {             
         SMG_Display_Data();
    }
}

三、24C02存储按键触发次数

基于小蜜蜂老师的进阶与冲刺_第11张图片 
#include "iic.h"
#include "reg52.h"

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

unsigned char s4_value = 0,s5_value = 0,s6_value = 0;
unsigned char code smg_data[] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8, 0x80,0x90};
//1.简单延时
void delay(unsigned int t)
{
     while(t--);
}

//2.锁存器初始化
void Init_74HC138(unsigned char 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;
        case 0:P2 = (P2 & 0x1f) | 0x00;break;
    }
    P2 = (P2 & 0x1f) | 0x00;
}

//3.数码管安位操作
void SMG_DisplayBit(unsigned char pos,unsigned char dat)
{
     P0 = (0x01 << pos);
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}

//4.操作所有数码管
void SMG_All(unsigned char dat)
{
     P0 = 0xff;
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}
//5.系统初始化
void Init_System(void)
{
     P0 = 0xff;
    Init_74HC138(4);
    P0 = 0x00;
    Init_74HC138(5);
    SMG_All(0xff);
}

//6.数码管显示数据
void SMG_Display_Data(void)
{
     SMG_DisplayBit(0,smg_data[s4_value/10]);
    delay(200);
    SMG_DisplayBit(1,smg_data[s4_value%10]);
    delay(200);
    SMG_DisplayBit(2,0xbf);
    delay(200);
    SMG_DisplayBit(3,smg_data[s5_value/10]);
    delay(200);
    SMG_DisplayBit(4,smg_data[s5_value%10]);
    delay(200);
    SMG_DisplayBit(5,0xbf);
    delay(200);
    SMG_DisplayBit(6,smg_data[s6_value/10]);
    delay(200);
    SMG_DisplayBit(7,smg_data[s6_value%10]);
    delay(200);
    SMG_All(0xff);
    delay(200);

}

//7.at24c02写数据
void AT24C02_Write(unsigned char addr,unsigned char dat)
{
     IIC_Start();
    IIC_SendByte(0xa0);
    IIC_WaitAck();
    IIC_SendByte(addr);
    IIC_WaitAck();
    IIC_SendByte(dat);
    IIC_WaitAck();
    IIC_Stop();
}

//8.at24c04读数据
unsigned char AT24C02_Read(unsigned char addr)
{
    unsigned char temp = 0;
    IIC_Start();
    IIC_SendByte(0xa0);
    IIC_WaitAck();
    IIC_SendByte(addr);
    IIC_WaitAck();

    IIC_Start();
    IIC_SendByte(0xa1);
    IIC_WaitAck();
    temp = IIC_RecByte();
    IIC_SendAck(1);
    IIC_Stop();
    return temp;
}

//9.系统上电后，先从24C04存储器的0x00、0x01和0x02这三个地址单元读取数据
void AT24C02_Data_Init(void)
{
     s4_value =     AT24C02_Read(0x00);
    delay(1000);
    s5_value =  AT24C02_Read(0x01);
    delay(1000);
    s6_value =  AT24C02_Read(0x02);
    delay(1000);

}

//10.按键控制
void Key_Scans(void)
{
 if(S4 == 0)
 {
        delay(20);
        if(S4 == 0)
        {
             while(S4 == 0);
            s4_value++;
            if(s4_value > 13)
            {
                 s4_value = 0;
            }
            AT24C02_Write(0x00,s4_value);
        }
 }
 
 if(S5 == 0)
 {
        delay(20);
        if(S5 == 0)
        {
             while(S5 == 0);
            s5_value++;
            if(s5_value > 13)
            {
                 s5_value = 0;
            }
            AT24C02_Write(0x01,s5_value);
        }
     }
    
    if(S6 == 0)
 {
        delay(20);
        if(S6 == 0)
        {
             while(S6 == 0);
            s6_value++;
            if(s6_value > 13)
            {
                 s6_value = 0;
            }
            AT24C02_Write(0x02,s6_value);
        }
 }                
}
void main(void)
{
    Init_System();
    AT24C02_Data_Init();
    while(1)
    {
        SMG_Display_Data() ;
        Key_Scans();
    }
     
}

四、采样可变电阻电压与光敏电阻电压

基于小蜜蜂老师的进阶与冲刺_第12张图片 
#include "iic.h"
#include "reg52.h"

sbit S4 = P3^3;
unsigned char channel = 1;
unsigned int adc_value = 0,adc_volt = 0;
unsigned char code smg_data[] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8, 0x80,0x90};
unsigned char code smg_dot[] ={0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10};

//1.简单延时
void delay(unsigned int t)
{
     while(t--);
}

//2.锁存器初始化
void Init_74HC138(unsigned char 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;
        case 0:P2 = (P2 & 0x1f) | 0x00;break;
    }
        P2 = (P2 & 0x1f) | 0x00;
}

//数码管安位操作
void SMG_DisplayBit(unsigned char pos,unsigned char dat)
{
     P0 = (0x01 << pos);
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}

//操作所有数码管
void SMG_All(unsigned char dat)
{
  P0 = 0xff;
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}

//系统初始化
void Init_System(void)
{
     P0 = 0xff;
    Init_74HC138(4);
    P0 = 0x00;
    Init_74HC138(5);
    SMG_All(0xff);
}

//数码管数据显示
void SMG_Display_Data(void)
{
     SMG_DisplayBit(0,0xbf);
    delay(200);
    SMG_DisplayBit(1,smg_data[channel]);
    delay(200);
    SMG_DisplayBit(2,0xbf);
    delay(200);
    SMG_DisplayBit(3,0xff);
    delay(200);
    SMG_DisplayBit(4,0xff);
    delay(200);
    SMG_DisplayBit(5,smg_dot[adc_volt/100]);
    delay(200);
    SMG_DisplayBit(6,smg_data[adc_volt/10%10]);
    delay(200);
    SMG_DisplayBit(7,smg_data[adc_volt%10]);
    delay(200);
    SMG_All(0xff);
    delay(200);
}

//PCF8591数据读取
void PCF8591_Read_Data(unsigned char channel)
{
    IIC_Start();
    IIC_SendByte(0x90);
    IIC_WaitAck();
    if(channel == 1)
    {
         IIC_SendByte(0x01);    
    }
    else if(channel == 3)
    {
         IIC_SendByte(0x03);    
    }
    IIC_WaitAck();
    IIC_Stop();

    IIC_Start();
    IIC_SendByte(0x91);
    IIC_WaitAck();
    adc_value = IIC_RecByte();
    IIC_SendAck(1);
    IIC_Stop();
    adc_volt = adc_value * (5.0/255)*100;        //扩大100倍方便显示         
}

//按键操作
void Key_Tackle(void)
{
     if(S4 == 0)
    {
         delay(20);
        if(S4 == 0)
        {
             while(S4 == 0)
            {
                 if(channel == 1)
                {
                     channel = 3;
                }
                else if(channel == 3)
                {
                     channel = 1;
                }
                PCF8591_Read_Data(channel);
              SMG_Display_Data();
            }

        }
    }
}

//主函数
void main(void)
{
     Init_System();
     while(1)
    {
        
        Key_Tackle();
        PCF8591_Read_Data(channel);
        SMG_Display_Data();
    }
}

七，巩固练习2

一、按键长按短与短按

基于小蜜蜂老师的进阶与冲刺_第13张图片 
#include "reg52.h"

//定义S4按键
sbit S4 = P3^3;
unsigned char t_count = 0,s_press = 0,value =28;    //计时，按键长按标志，数值
unsigned char code smg_data[18]={0xc0,0xf9,
    0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
    0x88,0x80,0xc6,0xc0,0x86,0x8e,0xbf,0x7f};    //段码




//简单延时
void delay(unsigned int t)
{
    while(t--);
}

//锁存器初始化
void Init_74HC138(unsigned char 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;
        case 0:P2 = (P2 & 0x1f) | 0x00;break;
    }
        P2 = (P2 & 0x1f) | 0x00;
}

//操作所有数码管
void SMG_All(unsigned char dat)
{    
    P0 = 0xff;
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}


//数码管安位操作
void SMG_DisplayBit(unsigned char pos,unsigned char dat)
{
     P0 = (0x01 << pos);
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}

//数码管显示数据
void SMG_Display_Data(void)
{
    SMG_DisplayBit(0,0xff);
    delay(200);
    SMG_DisplayBit(1,0xff);
    delay(200);
    SMG_DisplayBit(2,0xff);
    delay(200);
    SMG_DisplayBit(3,0xff);
    delay(200);
    SMG_DisplayBit(4,0xff);
    delay(200);
    SMG_DisplayBit(5,0xff);
    delay(200);
    SMG_DisplayBit(6,smg_data[value/10]);
    delay(200);
    SMG_DisplayBit(6,0xff);
    delay(200);
    SMG_DisplayBit(7,smg_data[value%10]);
    delay(200);
    SMG_DisplayBit(7,0xff);
    SMG_All(0xff);
    delay(200);
}





//系统初始化
void Init_System(void)
{
     P0 = 0xff;
    Init_74HC138(4);
    P0 = 0x00;
    Init_74HC138(5);
    SMG_All(0xff);
}


//按键处理
void Key_Scan(void)
{
     if(S4 == 0)
    {
        delay(20);
        if(S4 == 0)
        {
            //这里一定注意要将标志位和计时清零
            s_press = 0;
            t_count = 0;
             while(S4 == 0)
            {
                 SMG_Display_Data();
            }
            if(s_press == 1) //长按模式
            {
                 value = 0;
            }
            else      //短按模式
            {
                value++;
                if(value > 99)
                {
                     value = 0;
                }
            }
            
        }
    }
}

//定时器初始化
void Init_Timer(void)
{
     TMOD = 0x01;
    TH0  =(65535-10000)/256;    //10ms
    TL0  =(65535-10000)%256;
    ET0  = 1;
    TR0  = 1;
    EA   = 1;
}
//主函数
void main(void)
{
     Init_System();
    Init_Timer();
    while(1)
    {
         Key_Scan();
        SMG_Display_Data();
    }
}

//定时器中断处理

void Server_Timer0() interrupt 1
{
     TH0 = (65535-10000)/256;
    TL0 = (65535-10000)%256;
    t_count++;
    if(t_count == 100) //1s
    {
         s_press = 1;  //长按标志
    }
}

二、采样光敏与可调电阻电压

基于小蜜蜂老师的进阶与冲刺_第14张图片 
#include "reg52.h"
#include "iic.h"

unsigned char rd1_value = 0,rd2_value = 0; //光敏与电阻采样变量
unsigned int smg_value1 = 0,smg_value2 =0; //数码管显示
//不带小数点段码
unsigned char code smg_data[18]={0xc0,0xf9,
    0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
    0x88,0x80,0xc6,0xc0,0x86,0x8e,0xbf,0x7f};
//带小数点段码
unsigned char code smg_data_dot[10]={0x40,0x79,
    0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10};

//简单延时
void delay(unsigned int t)
{
     while(t--);
}

//锁存器初始化
void Init_74HC138(unsigned char 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;
        case 0:P2 = (P2 & 0x1f) | 0x00;break;
    }
        P2 = (P2 & 0x1f) | 0x00;
}

//数码管安位操作
void SMG_DisplayBit(unsigned char pos,unsigned char dat)
{
     P0 = (0x01 << pos);
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}

//操作所有数码管
void SMG_All(unsigned char dat)
{
     P0  = 0xff;
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}


//数码管数据显示
void SMG_Display_V(void)
{
    //光敏电压显示
     SMG_DisplayBit(0,smg_data_dot[smg_value1/100]);
     delay(200);
     SMG_DisplayBit(0,0xff);
     delay(200);
     SMG_DisplayBit(1,smg_data[smg_value1/10%10]);
     delay(200);
     SMG_DisplayBit(1,0xff);
     delay(200);
     SMG_DisplayBit(2,smg_data[smg_value1%10]);
     delay(200);
     SMG_DisplayBit(2,0xff);
     delay(200);
     SMG_DisplayBit(3,0xff);
     delay(200);
     SMG_DisplayBit(4,0xff);
     delay(200);
     //电阻电压显示
     SMG_DisplayBit(5,smg_data_dot[smg_value2/100]);
     delay(200);
     SMG_DisplayBit(5,0xff);
     SMG_DisplayBit(6,smg_data[smg_value2/10%10]);
     delay(200);
     SMG_DisplayBit(6,0xff);
     delay(200);
     SMG_DisplayBit(7,smg_data[smg_value2%10]);
     delay(200);
     SMG_DisplayBit(7,0xff);
     delay(200);
     SMG_All(0xff);
     delay(200);
}

//读取光敏数据
void Read_AD1(void)
{
    IIC_Start();
    IIC_SendByte(0x90);
    IIC_WaitAck();    
    IIC_SendByte(0x01);
    IIC_WaitAck();
    IIC_Stop();
    
    IIC_Start();
    IIC_SendByte(0x91);
    IIC_WaitAck();    
    rd1_value = IIC_RecByte();
    IIC_SendAck(1);
    IIC_Stop();
    smg_value1 = rd1_value * (5.0/255) * 100;
}

//读取电阻数据
void Read_AD2(void)
{
     
    IIC_Start();
    IIC_SendByte(0x90);
    IIC_WaitAck();    
    IIC_SendByte(0x03);
    IIC_WaitAck();
    IIC_Stop();
    
    IIC_Start();
    IIC_SendByte(0x91);
    IIC_WaitAck();    
    rd2_value = IIC_RecByte();
    IIC_SendAck(1);
    IIC_Stop();
    smg_value2 = rd2_value * (5.0/255) * 100;
}


//系统初始化
void Init_System(void)
{
     P0 = 0xff;
    Init_74HC138(4);
    P0 = 0x00;
    Init_74HC138(5);
    SMG_All(0xff);
}


//主函数
void main(void)
{
     Init_System();
    while(1)
    {
            Read_AD1();
            Read_AD2();
            SMG_Display_V();
    }
}

三、基于PCF8591的DAC模拟电压输出

基于小蜜蜂老师的进阶与冲刺_第15张图片 
#include "reg52.h"
#include "iic.h"


sbit S4 = P3^3;    //引脚定义
unsigned char mode = 1; //输出模式
unsigned int volt_value = 0,ad_value = 0;     //数码管显示电压、采样变量
//不带小数点段码
unsigned char code smg_data[18]={0xc0,0xf9,
    0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
    0x88,0x80,0xc6,0xc0,0x86,0x8e,0xbf,0x7f};
//带小数点段码
unsigned char code smg_data_dot[10]={0x40,0x79,
    0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10};


//简单延时
void delay(unsigned int t )
{
     while(t--);
}

//锁存器初始化
void Init_74HC138(unsigned char 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;
        case 0:P2 = (P2 & 0x1f) | 0x00;break;
    }
        P2 = (P2 & 0x1f) | 0x00;
}

//数码管安位操作
void  SMG_DisplayBit(unsigned char pos,unsigned char dat)
{
     P0 = (0x01 << pos);
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}

//操作所有数码管
void SMG_All(unsigned char dat)
{
     P0 = 0xff;
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}

//数码管数据显示
void SMG_Display_Data(void)
{
     SMG_DisplayBit(0,0xbf);
     delay(200);
     SMG_DisplayBit(0,0xff);
     delay(200);
     SMG_DisplayBit(1,smg_data[mode]);
     delay(200);
     SMG_DisplayBit(1,0xff);
     delay(200);
     SMG_DisplayBit(2,0xbf);
     delay(200);
     SMG_DisplayBit(2,0xff);
     delay(200);
     SMG_DisplayBit(3,0xff);
     delay(200);
     SMG_DisplayBit(4,0xff);
     delay(200);
     SMG_DisplayBit(5,smg_data_dot[volt_value/100]);
     delay(200);
     SMG_DisplayBit(5,0xff);
     delay(200);
     SMG_DisplayBit(6,smg_data[volt_value/10%10]);
     delay(200);
     SMG_DisplayBit(6,0xff);
     delay(200);
     SMG_DisplayBit(7,smg_data[volt_value%10]);
     delay(200);
     SMG_DisplayBit(7,0xff);
     delay(200);
     SMG_All(0xff);
     delay(200);

}    

//PCF8591数据读取
void Read_ADC(void)
{
    IIC_Start();
    IIC_SendByte(0x90);
    IIC_WaitAck();
    IIC_SendByte(0x43);
    IIC_WaitAck();
    IIC_Stop();

    IIC_Start();
    IIC_SendByte(0x91);
    IIC_WaitAck();
    ad_value = IIC_RecByte();
    IIC_SendAck(1);
    IIC_Stop();
    volt_value = ad_value * (5.0/255)* 100;
}

void Read_DAC(float dat)
{
     IIC_Start();
    IIC_SendByte(0x90);
    IIC_WaitAck();
    IIC_SendByte(0x43);
    IIC_WaitAck();
    IIC_SendByte(dat);
    IIC_WaitAck();
    IIC_Stop();
}



//系统初始化
void Init_System(void)
{
     P0 = 0xff;
    Init_74HC138(4);
    P0 = 0x00;
    Init_74HC138(5);
    SMG_All(0xff);
}


//按键处理
void Key_Scans(void)
{
     if(S4 == 0)
    {
         delay(20);
        if(S4 == 0)
        {
             while(S4 == 0)
            {
                     SMG_Display_Data();
            }
            if(mode == 1)
            {
                 mode = 2;
            }
            else if(mode == 2)
            {
                 mode = 3;
            }
            else if(mode == 3)
            {
                mode = 1;
            }

        }
    }
}
//主函数
void main(void)
{
     Init_System();
    while(1)
    {
            Key_Scans();
            switch(mode)
            {
                 case 1:Read_DAC(102);volt_value = 2*100;break;
                case 2:Read_DAC(204);volt_value = 4*100;break;
                case 3:Read_ADC();Read_DAC(ad_value);break;
            }
            SMG_Display_Data();
    }

}

八，电压信号探测器

基于小蜜蜂老师的进阶与冲刺_第16张图片 
#include "reg52.h"
#include "iic.h"

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

unsigned int adc_volt = 0,volt = 0;     //采集电压 和数码管显示变量
unsigned int param_volt = 300,alarm_count = 0;//电压参数 、计数参数
unsigned char alarm_flag = 0,flash_flag = 0;//报警标志 、闪烁标志
unsigned char led_stat = 0xff;    //led状态
unsigned int t_count = 0;//计时
unsigned char interface = 0;     //界面切换
unsigned char code smg_data[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80};
unsigned char code smg_data_dot[]={0xc0-0x80,0xf9-0x80,0xa4-0x80,0xb0-0x80,0x99-0x80,0x92-0x80,0x82-0x80,0xf8-0x80,0x80-0x80};
void delay(unsigned int t)
{
     while(t--);
}

void Init_74HC138(unsigned char 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;
        case 0:P2 = (P2 & 0x1f) | 0x00;break; 
    }
        P2 = (P2 & 0x1f) | 0x00; 
}

void SMG_All(unsigned char dat)
{
     P0 = 0xff;
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}


void SMG_DisplayBit(unsigned char pos,unsigned char dat)
{
     P0 = (0x01 << pos);
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}


void Read_ADC(void)
{
    IIC_Start();
    IIC_SendByte(0x90);
    IIC_WaitAck();
    IIC_SendByte(0x03);
    IIC_WaitAck();
    IIC_Stop();

    IIC_Start();
    IIC_SendByte(0x91);
    IIC_WaitAck();
    adc_volt = IIC_RecByte();
    IIC_SendAck(1);
    IIC_Stop();
    //数据处理
    volt = adc_volt * (5.0/255)*100;
}


void SMG_Display_Data(void)
{
    SMG_DisplayBit(1,0xff);
    delay(200);
    SMG_DisplayBit(2,0xff);
    delay(200);
    SMG_DisplayBit(3,0xff);
    delay(200);
    SMG_DisplayBit(4,0xff);
    delay(200);
    if(interface == 0)
    {
            //U 1000 0011 0xc1
         SMG_DisplayBit(0,0xc1);
        delay(200);
        SMG_DisplayBit(5,smg_data_dot[volt/100]);
        delay(200);
        SMG_DisplayBit(6,smg_data[volt/10%10]);
        delay(200);
        SMG_DisplayBit(7,smg_data[volt%10]);
        delay(200);
    }
    else if(interface == 1)
    {
        //P 0011 0001 0x8c
        SMG_DisplayBit(0,0x8c);
        delay(200);
        SMG_DisplayBit(5,smg_data_dot[param_volt/100]);
        delay(200);
        SMG_DisplayBit(6,smg_data[param_volt/10%10]);
        delay(200);
        SMG_DisplayBit(7,smg_data[param_volt%10]);
        delay(200);
    }
    else if(interface == 2)
    {
         //S 
        SMG_DisplayBit(0,0x92);
        delay(200);
        SMG_DisplayBit(5,0xff);
        delay(200);
        if(alarm_count > 9)
        {
            SMG_DisplayBit(6,smg_data[alarm_count/10]);
            delay(200);
        }
        SMG_DisplayBit(7,smg_data[alarm_count%10]);
        delay(200);
    }
    SMG_All(0xff);
    delay(200);
}

void Key_Scans(void)
{
    //S4界面切换
     if(S4 == 0)
    {
         delay(20);
        if(S4 == 0)
        {
             while(S4 == 0)
            {
                SMG_Display_Data();
            }
                 if(interface == 0)
                {
                     interface = 1;
                }
                else if(interface == 1)
                {
                    interface = 2;
                }
                else if(interface == 2)
                {
                     interface = 0;
                }
            }
    }
    //电压参数减0.5v每次
    if(S5 == 0)
    {
         delay(20);
        if(S5 == 0)
        {
             while(S5 == 0)
            {
                 SMG_Display_Data();
            }
            if(interface == 1)
            {
                  param_volt -= 50; //扩大100倍 分别显示处理
                 if(param_volt == 0)//边界处理
                 {
                         //减到最小值后 变成最大
                        param_volt = 500;
                 }
            }
        }
    }

        //电压参数加0.5v每次
    if(S6 == 0)
    {
         delay(20);
        if(S6 == 0)
        {
             while(S6 == 0)
            {
                 SMG_Display_Data();
            }
            if(interface == 1)
            {
                  param_volt += 50; //扩大100倍 分别显示处理
                 if(param_volt == 500)//边界处理
                 {
                         //加到最大值后变成最小值
                        param_volt = 0;
                 }
            }
        }
    }
}

void Led_Tackle(void)
{
     if(volt < param_volt)
    {     
        if(alarm_flag == 0)
        {
             alarm_flag = 1; //报警标志
        }
    }
    else
    {
         alarm_flag = 0;
        flash_flag = 0;
        t_count = 0;
        alarm_count = 0;
        led_stat |= 0xff;
        P0 = led_stat;
        Init_74HC138(4);
    }
}
void Init_Timer(void)
{
     TMOD = 0x01;
    TH0  = (65535-50000)/256;
    TL0  = (65535-50000)%256;
    ET0  = 1;
    TR0  = 1;
    EA   = 1;
}
void Init_System(void)
{
     P0 = 0xff;
    Init_74HC138(4);
    P0 = 0x00;
    Init_74HC138(5);
    SMG_All(0xff);
}

void main(void)
{
      Init_System();
     Init_Timer();
     while(1)
     {
             Read_ADC();
            Key_Scans();
            SMG_Display_Data();
            Led_Tackle();
     }
}

void Server_Timer0() interrupt 1
{
     TH0  = (65535-50000)/256;
    TL0  = (65535-50000)%256;
    //启动报警
    if(alarm_flag == 1)
    {
         t_count++;
         if(t_count % 20 == 0) //1s
         {
                 //还未到达最值计数值
                if(alarm_count != 99)
                {
                     alarm_count++; 
                }
                //秒闪标志
                if(flash_flag == 1)
                {
                    if(led_stat & 0x80 == 0x80)
                    {    
                        led_stat &= (~0x80); //点亮L8
                    }
                    else
                    {
                         led_stat |= 0x80; //熄灭L8
                    }
                }
         }

         if(t_count > 120) //超过6s
         {
                led_stat &= (~0x07);  //点亮L1 L2 L 3
                flash_flag = 1;
         }
         else if(t_count > 80) //超过4s
         {
                led_stat &= (~0x03);
         }
         else if(t_count > 40) //超过2s
         {
                led_stat &= (~0x01); //L1亮
         }
         else
         {
                led_stat = 0xff;//关闭LED
         }
             P0 = led_stat;
             Init_74HC138(4);
    }    
}
基于小蜜蜂老师的进阶与冲刺_第17张图片 
#include "reg52.h"
#include "iic.h"

sbit S5 = P3^2;
sbit S4 = P3^3;
unsigned int temp = 0;
unsigned char led_stat = 0xff; //led 状态
unsigned char adc_volt= 0,old_volt = 0; //电压采集
unsigned int volt = 0;    //数码管显示电压
unsigned char old_grade = 0,grade = 0; //灯光等级
//0-9 段码
unsigned char code smg_data[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80};
//0.-9.段码
unsigned char code smg_data_dot[]={0xc0-0x80,0xf9-0x80,0xa4-0x80,0xb0-0x80,0x99-0x80,0x92-0x80,0x82-0x80,0xf8-0x80,0x80-0x80};

//简单延时
void delay(unsigned int t)
{
     while(t--);
}

//锁存器初始化
void Init_74HC138(unsigned char 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;
        case 0:P2 = (P2 & 0x1f) | 0x00;break; 
    }
        P2 = (P2 & 0x1f) | 0x00; 
}

//操作所有数码管

void SMG_All(unsigned char dat)
{
     P0 = 0xff;
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}
//数码管安位操作
void SMG_DisplayBit(unsigned char pos,unsigned char dat)
{
     P0 = (0x01 << pos);
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}


//数码管数据显示
void SMG_Display_V(void)
{
     SMG_DisplayBit(0,0xbf);
    delay(200);
    SMG_DisplayBit(1,smg_data[grade]);
    delay(200);
    SMG_DisplayBit(2,0xbf);
    delay(200);
    SMG_DisplayBit(3,0xff);
    delay(200);
    SMG_DisplayBit(4,0xff);
    delay(200);
    SMG_DisplayBit(5,smg_data_dot[volt/100]);
    delay(200);
    SMG_DisplayBit(6,smg_data[volt/10%10]);
    delay(200);
    SMG_DisplayBit(7,smg_data[volt%10]);
    delay(200);
    SMG_All(0xff);
    delay(200);
}


//读取光敏通道电压
void Read_ADC(void)
{
    IIC_Start();
    IIC_SendByte(0x90);
    IIC_WaitAck();
    IIC_SendByte(0x01);
    IIC_WaitAck();
    IIC_Stop();
    SMG_Display_V();
    IIC_Start();
    IIC_SendByte(0x91);
    IIC_WaitAck();
    adc_volt = IIC_RecByte();
    IIC_SendAck(1);
    IIC_Stop();
    //数据处理
    volt = adc_volt * (5.0/255)*100;
    SMG_Display_V();
}




//灯光控制
void Led_Working(void)
{
     Read_ADC();
    //等级0 全部灯熄灭
    if(volt <= 500 && volt > 450)
    {
         grade = 0;
         led_stat = 0xff;
    }
    //等级1 L1 点亮
    else if(volt <= 450 && volt > 400)
    {
         grade = 1;
        led_stat = 0xfe;
    }
    //等级2  L1-L2 亮
    else if(volt <= 400 && volt > 350)
    {
        grade = 2;
         led_stat = 0xfc;
    }
    //等级3 L1-L3 亮
    else if(volt <= 350 && volt > 300)
    {
        grade = 3;
        led_stat = 0xf8;
    }

        //等级4 L1-L4 点亮
    else if(volt <= 300 && volt > 250)
    {
         grade = 4;
        led_stat = 0xf0;     
    }
    //等级5  L1- L5 亮
    else if(volt <= 250 && volt > 200)
    {
         grade = 5;
        led_stat = 0xe0;
    }
    //等级6 L1-L6 亮
    else if(volt <= 200 && volt > 150)
    {
        grade = 6;
        led_stat = 0xc0;  
    }
     //等级7 L1-L7 亮
    else if(volt <= 150 && volt > 100)
    {
         grade = 7;
        led_stat = 0x80; 
    }
    //等级8 L1-L8 亮
    else if(volt <= 50 && volt > 0)
    {
        grade = 8;
        led_stat = 0x00;;
    }

    P0 = led_stat;
    Init_74HC138(4);
}


//AT24C02处理
void Write_AT24C02(unsigned char addr,unsigned char dat)
{
     IIC_Start();
    IIC_SendByte(0xa0);
    IIC_WaitAck();
    IIC_SendByte(addr);
    IIC_WaitAck();
    IIC_SendByte(dat);
    IIC_WaitAck();
    IIC_Stop();
}

//读AT24C02
unsigned int Read_AT24C02(unsigned char addr)
{
    IIC_Start();
    IIC_SendByte(0xa0);
    IIC_WaitAck();
    IIC_SendByte(addr);
    IIC_WaitAck();

    IIC_Start();
    IIC_SendByte(0xa1);
    IIC_WaitAck();
    temp = IIC_RecByte();
    IIC_SendAck(1);
    IIC_Stop();
    return temp;
}

//保存当前数据
void Save_To_24C02(void)
{
      Write_AT24C02(0x01,grade);
     SMG_Display_V();
     Write_AT24C02(0x02,volt);
     SMG_Display_V();
}


//读取历史数据
void Read_From_24c02(void)
{
        old_grade = Read_AT24C02(0x01);
        delay(500);
        old_volt = Read_AT24C02(0x02);
        delay(500);
        grade = old_grade;
        volt     = old_volt;
}
//按键处理
void Key_Scans(void)
{
     if(S4 == 0)
    {
         delay(20);
        if(S4 == 0)
        {
            Save_To_24C02();
             while(S4 == 0)
            {
                 Led_Working();
            }
            
        }
    }

    if(S5 == 0)
    {
        delay(20);
        if(S5 == 0)
        {
            //关闭所有灯光
             led_stat = 0xff;
            P0 = led_stat;
            Init_74HC138(4);
            //读取数据
            Read_From_24c02();
            while(S5 == 0)
            {
                  SMG_Display_V();    
            }

        }
    }
}
//系统初始化
void Init_System(void)
{
     P0 = 0xff;
    Init_74HC138(4);
    P0 = 0x00;
    Init_74HC138(5);
    SMG_All(0xff);
}



//主函数
void main(void)
{
    Init_System();
    while(1)
    {
    
         Led_Working();
         Key_Scans();
    }

}
基于小蜜蜂老师的进阶与冲刺_第18张图片 
#include "reg52.h"
#include "iic.h"

/******************************************************************
*第十三届蓝桥杯省赛软件部分实现                                      *
*Author:小殷童鞋                                                   *
*Date:2022-12-13                                                  *      
*******************************************************************/
sbit S4 = P3^3;
sbit S5 = P3^2;
sbit S6 = P3^1;
sbit S7 = P3^0;

unsigned int f_count = 0,count = 0,period = 0;   //频率  显示频率  周期变量
unsigned char Rd_Data = 0,Rd_Volt = 0, channel = 1; //通道模拟数据 电压 和通道变量
unsigned char interface = 1;     //界面
unsigned int old_volt = 0,old_f = 0; //缓存电压和频率
unsigned char long_press_flag = 0,t_count = 0,press_count = 0; //长按标志 计时  长按次数变量
unsigned char led_flag = 1,led_status = 0xff,old_led_status = 0xff;//led启动标志 led状态 led旧状态变量
//共阳
unsigned char code SMG_Duan[] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,
                                 0x80,0x90,0x88,0x83,0xC6,0xA1,0x86,0x8E,0xbf}; //数码管段码

unsigned char code smg_dot[] ={0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10}; //带小数点
//简单延时
void delay(unsigned int t)
{
    while(t--);
}
//744HC138初始化
void Init_74HC138(unsigned char dat)
{
    switch(dat)
    {
        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;
        case 0:P2 = (P2 & 0x1f) | 0x00;break;
    }
    P2 = (P2 & 0x1f) | 0x00;
}

//数码管按位操作
void SMG_DisplayByBit(unsigned char pos,unsigned char dat)
{
    P0 = (0x01 << pos);
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}

//操作所有数码管
void Controal_All_SMG(unsigned char dat)
{
    P0 = 0xff;
    Init_74HC138(6);
    P0 = dat;
    Init_74HC138(7);
}

//数码管数据显示频率
void SMG_Display_Frequent(void)
{
    SMG_DisplayByBit(0,SMG_Duan[15]);
    delay(200);
    if(count > 999999)
    {
        SMG_DisplayByBit(1,SMG_Duan[count/1000000]);
        delay(200);
    }
    if(count > 99999)
    {
        SMG_DisplayByBit(2,SMG_Duan[count/100000%10]);
        delay(200);
    }
    if(count > 9999)
    {
        SMG_DisplayByBit(3,SMG_Duan[count/10000%10]);
        delay(200);
    }
    if(count > 999)
    {
        SMG_DisplayByBit(4,SMG_Duan[count/1000%10]);
        delay(200);
    }
    if(count > 99)
    {
        SMG_DisplayByBit(5,SMG_Duan[count/100%10]);
        delay(200);
    }
    
    if(count > 9)
    {
        SMG_DisplayByBit(6,SMG_Duan[count/10%10]);
        delay(200);
    }    
    SMG_DisplayByBit(7,SMG_Duan[count%10]);
    delay(200);
    Controal_All_SMG(0xff);
    delay(200);
    
}


//周期显示
void SMG_Display_Period(void)
{
    SMG_DisplayByBit(0,~0x37);
    delay(200);
    if(count > 999999)
    {
        SMG_DisplayByBit(1,SMG_Duan[period/1000000]);
        delay(200);
    }
    if(count > 99999)
    {
        SMG_DisplayByBit(2,SMG_Duan[period/100000%10]);
        delay(200);
    }
    if(count > 9999)
    {
        SMG_DisplayByBit(3,SMG_Duan[period/10000%10]);
        delay(200);
    }
    if(count > 999)
    {
        SMG_DisplayByBit(4,SMG_Duan[period/1000%10]);
        delay(200);
    }
    if(count > 99)
    {
        SMG_DisplayByBit(5,SMG_Duan[period/100%10]);
        delay(200);
    }
    
    if(count > 9)
    {
        SMG_DisplayByBit(6,SMG_Duan[period/10%10]);
        delay(200);
    }    
    SMG_DisplayByBit(7,SMG_Duan[period%10]);
    delay(200);
    Controal_All_SMG(0xff);
    delay(200);
    
}


//PCF8591电压采集
void PCF8591_Volt_Rd1(unsigned char channel)
{
    IIC_Start();
    IIC_SendByte(0x90);
    IIC_WaitAck();
    if(channel == 1)
    {
        IIC_SendByte(0x01);    //光敏
    }
    else if(channel == 3)
    {
        IIC_SendByte(0x03);    //电压
    }
    IIC_WaitAck();
    IIC_Stop();
    
    IIC_Start();
    IIC_SendByte(0x91);
    IIC_WaitAck();
    Rd_Data = IIC_RecByte();
    IIC_SendAck(1);
    IIC_Stop();
    Rd_Volt = Rd_Data * (5.0/255)  * 100;    //扩大100倍方便显示    
}



//数码管电压显示数据
void SMG_Display_Volt(void)
{
    SMG_DisplayByBit(0,~0x3e);
    delay(200);
    SMG_DisplayByBit(1,0xbf);
    delay(200);
    SMG_DisplayByBit(2,SMG_Duan[channel]);       //通道编号
    delay(200);
    SMG_DisplayByBit(3,0xff);
    delay(200);
    SMG_DisplayByBit(4,0xff);
    delay(200);

    SMG_DisplayByBit(5,smg_dot[Rd_Volt/100]);    //电压
    delay(200);
    SMG_DisplayByBit(6,SMG_Duan[Rd_Volt/10%10]);
    delay(200);
    SMG_DisplayByBit(7,SMG_Duan[Rd_Volt%10]);
    delay(200);
    Controal_All_SMG(0xff);
    delay(200);    
}

//按键控制
void Key_Scans(void)
{
    if(S4 == 0)
    {
        delay(20);
        if(S4 == 0)
        {
            while(S4 == 0)
            {
                //在按键一直按下时 避免数码管熄灭  根据相应的界面显示相应的数据
                if(interface == 1)
                {
                    SMG_Display_Frequent();
                }
                else if(interface == 2)
                {
                    SMG_Display_Period();
                }
                else if(interface == 3)
                {
                    SMG_Display_Volt();                                                         
                }
            }
            if(interface == 1)
            {
                interface = 2;
            }
            else if(interface == 2)
            {
                interface = 3;
            }
            else if(interface == 3)
            {
                interface = 1;
            }
        }
    }
    
    if(interface == 3)
    {
        
        //S5通道切换
        if(S5 == 0)
        {
            delay(20);
            if(S5 == 0)
            {                
                while(S5 == 0)
                {
                    PCF8591_Volt_Rd1(channel);
                    SMG_Display_Volt();
                }
                if(channel == 1)
                      {
                        channel = 3;
                    }
                    else if(channel == 3)
                    {
                        channel = 1;
                    }
                
            }
        }
    }
    
    //S6缓存channel 电压
    if(S6 == 0)
    {
        delay(20);
        if(S6 == 0)
        {
            t_count = 0;
            long_press_flag = 0;

            while(S6 == 0)
            {
                //在按键一直按下时 避免数码管熄灭  根据相应的界面显示相应的数据
                if(interface == 1)
                {
                    SMG_Display_Frequent();
                }
                else if(interface == 2)
                {
                    SMG_Display_Period();
                }
                else if(interface == 3)
                {
                    SMG_Display_Volt();                                                         
                }
                
                if(long_press_flag == 1) //长按
                {
                    if(press_count == 0)
                    {
                        press_count = 1;
                        led_flag = 0;  //禁用LED 全部熄灭
                        old_led_status = led_status; //缓存Led状态
                        P0 = 0xff;
                        Init_74HC138(4);
                    }
                    else if(press_count == 1)
                    {
                        //恢复LED功能
                        press_count = 0;
                        led_status = old_led_status; //将缓存的LED状态重新赋值给led_status
                        led_flag = 1;                //启用LED功能
                    }
                    
                }
                else{
                    if(channel == 3)
                    {
                        old_volt = Rd_Volt;
                    }
                }
                
            }
            
        }
    }
    
    
    //S7缓存频率
    if(S7 == 0)
    {
        delay(20);
        if(S7 == 0)
        {
            while(S7 == 0)
            {
                //在按键一直按下时 避免数码管熄灭  根据相应的界面显示相应的数据
                if(interface == 1)
                {
                    SMG_Display_Frequent();
                }
                else if(interface == 2)
                {
                    SMG_Display_Period();
                }
                else if(interface == 3)
                {
                    SMG_Display_Volt();                                                         
                }
            }
            old_f = count;     //将实时采集的频率count的值缓存到old_f变量中
        }
    }
}

//定时器初始化
void Init_Timer(void)
{
    TMOD = 0x16;  //定时器0计数 定时器1定时
    TH0  = 0xff;
    TL0  = 0xff;
    TH1  = (65535 - 50000)/256;  //高八位50ms
    TL1  = (65535 - 50000)%256;    
    ET0  = 1;
    ET1  = 1;
    TR0  = 1;
    TR1  = 1;
    EA   = 1;
}

//系统初始化
void Init_System(void)
{
    Init_74HC138(0);
    Controal_All_SMG(0xff);
    P0 = 0xff;
    Init_74HC138(4);
    P0 = 0x00;
    Init_74HC138(5);
}


//主函数
void main(void)
{
    Init_System();          //系统初始化
    Init_Timer();           //定时器初始化
    while(1)
    {
        PCF8591_Volt_Rd1(channel);
        Key_Scans();
        switch(interface)
        {
            case 1:SMG_Display_Frequent();break;
            case 2:SMG_Display_Period();break;
            case 3:SMG_Display_Volt();break;
        }
        if(led_flag == 1)
        {
            if(old_volt < Rd_Volt) //L1 open
            {
                led_status =  0xfe;     //0111 1111
            }
            if(old_f < count)
            {
                led_status &= 0xfd;       //1011 1111
            }
            if(interface == 1)
            {
                led_status &= 0xfb;    //1101  1111
            }
            if(interface == 2)
            {
                led_status &= 0xf7;  //1110 1111
            }
            if(interface == 3)
            {
                led_status &= 0xef; //1111  0111
            }
            P0 = led_status;
            Init_74HC138(4);
        }
    }
}


void Timer0_Server() interrupt 1
{
    f_count++;
}

void Timer1_Server() interrupt 3
{
    static unsigned char t = 0;
    TH1  = (65535 - 50000)/256;  //高八位50ms
    TL1  = (65535 - 50000)%256;    
    t++;
    t_count++;
    if(t == 20)  //1s
    {
        count = f_count;
        period = (1.0/count) * 1000000;
        f_count = 0;
        t = 0;
    }
    if(t_count >= 20) //超过或等于1s
    {
        long_press_flag = 1;
    }
}

你可能感兴趣的:(蓝桥,单片机,嵌入式硬件)

  • 基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程 极客小张 stm32qt机器人物联网人机交互毕业设计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个月内找到工作？ 无际单片机编程 单片机嵌入式开发物联网stm32c语言
    每个初学者，都如履薄冰，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
  • 【OpenHarmony嵌入式硬件开发】基于OpenHarmony标准系统的C++公共基础类库案例2：SafeMap 青少年编程作品集 嵌入式硬件c++javasqlharmonyos华为华为云
    1、程序简介该程序是基于OpenHarmony的C++公共基础类库的安全关联容器：SafeMap。OpenHarmony提供了一个线程安全的map实现。SafeMap在STLmap基础上封装互斥锁，以确保对map的操作安全。本案例主要完成如下工作：创建1个子线程，负责每秒调用EnsureInsert()插入元素；创建1个子线程，负责每秒调用Insert()插入元素；创建1个子线程，负责每秒调用Er
  • 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备赛蓝桥杯javapythonc++
    这类题目较为简单，就不写解析了，提供三种语言的参考代码，欢迎在评论区讨论！分离整数的各个位数#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
  • 实现单片机简单的时间片轮询调度 盘大海 单片机stm3251单片机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均为偶数，请问在这种情况下共有多少种不同
  • 嵌入式硬件_面试题 vip451 嵌入式硬件
    1、电路是由那几部分组成？2、什么是模拟信号、什么是数字信号？看看你们举出几个例子？1.电源，负载，开关，链接导线2.模拟信号是指：物理量的变化在时间上和幅度上都是连续的。把表示模拟量的信号称为模拟信号，并把工作在模拟信号下的电路称为模拟电路。声音、温度、速度等都是模拟信号。数字信号是指：物理量的变化在时间上和数值（幅度）上都是不连续（或称为离散）的。把表示数字量的信号称为数字信号，并把工作在数字
  • 在单片机中，处于高阻态是什么状态 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前言近期不少学弟学妹询问学长关于单片机和嵌入式相关的毕设选题，学长特意写下这篇文章以作回应！以下是学长亲手整理的物联网相关的毕业设计选题，都是经过学长精心审核的题目，适合作为毕设，难度不高，工作量达标，对毕设有任何疑问都可以问学
  • java封装继承多态等 麦田的设计者 javaeclipsejvmcencapsulatopn
           最近一段时间看了很多的视频却忘记总结了，现在只能想到什么写什么了，希望能起到一个回忆巩固的作用。     1、final关键字       译为：最终的        &
  • F5与集群的区别 bijian1013 weblogic集群F5
            http请求配置不是通过集群，而是F5；集群是weblogic容器的，如果是ejb接口是通过集群。         F5同集群的差别，主要还是会话复制的问题，F5一把是分发http请求用的，因为http都是无状态的服务，无需关注会话问题，类似
  • LeetCode[Math] - #7 Reverse Integer Cwind java题解MathLeetCodeAlgorithm
    原题链接：#7 Reverse Integer   要求： 按位反转输入的数字 例1： 输入 x = 123, 返回 321 例2： 输入 x = -123, 返回 -321   难度：简单   分析： 对于一般情况，首先保存输入数字的符号，然后每次取输入的末位（x%10）作为输出的高位（result = result*10 + x%10）即可。但
  • BufferedOutputStream 周凡杨
         首先说一下这个大批量，是指有上千万的数据量。      例子：      有一张短信历史表，其数据有上千万条数据，要进行数据备份到文本文件，就是执行如下SQL然后将结果集写入到文件中！      select t.msisd
  • linux下模拟按键输入和鼠标 被触发 linux
    查看/dev/input/eventX是什么类型的事件， cat /proc/bus/input/devices 设备有着自己特殊的按键键码，我需要将一些标准的按键，比如0－9，X－Z等模拟成标准按键，比如KEY_0,KEY-Z等，所以需要用到按键 模拟，具体方法就是操作/dev/input/event1文件，向它写入个input_event结构体就可以模拟按键的输入了。 linux/in
  • ContentProvider初体验 肆无忌惮_ ContentProvider
    ContentProvider在安卓开发中非常重要。与Activity，Service，BroadcastReceiver并称安卓组件四大天王。 在android中的作用是用来对外共享数据。因为安卓程序的数据库文件存放在data/data/packagename里面，这里面的文件默认都是私有的，别的程序无法访问。 如果QQ游戏想访问手机QQ的帐号信息一键登录，那么就需要使用内容提供者COnte
  • 关于Spring MVC项目（maven）中通过fileupload上传文件 843977358 mybatisspring mvc修改头像上传文件upload
    Spring MVC 中通过fileupload上传文件，其中项目使用maven管理。   1.上传文件首先需要的是导入相关支持jar包：commons-fileupload.jar,commons-io.jar 因为我是用的maven管理项目，所以要在pom文件中配置（每个人的jar包位置根据实际情况定） <!-- 文件上传 start by zhangyd-c --&g
  • 使用svnkit api，纯java操作svn，实现svn提交，更新等操作 aigo svnkit
     原文：http://blog.csdn.net/hardwin/article/details/7963318   import java.io.File; import org.apache.log4j.Logger; import org.tmatesoft.svn.core.SVNCommitInfo; import org.tmateso
  • 对比浏览器，casperjs，httpclient的Header信息 alleni123 爬虫crawlerheader
    @Override protected void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException { String type=req.getParameter("type"); Enumeration es=re
  • java.io操作 DataInputStream和DataOutputStream基本数据流 百合不是茶 java流
    1，java中如果不保存整个对象，只保存类中的属性，那么我们可以使用本篇文章中的方法，如果要保存整个对象  先将类实例化  后面的文章将详细写到     2，DataInputStream 是java.io包中一个数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。
  • 车辆保险理赔案例 bijian1013 车险
    理赔案例： 一货运车，运输公司为车辆购买了机动车商业险和交强险，也买了安全生产责任险，运输一车烟花爆竹，在行驶途中发生爆炸，出现车毁、货损、司机亡、炸死一路人、炸毁一间民宅等惨剧，针对这几种情况，该如何赔付。 赔付建议和方案： 客户所买交强险在这里不起作用，因为交强险的赔付前提是：“机动车发生道路交通意外事故”； 如果是交通意外事故引发的爆炸，则优先适用交强险条款进行赔付，不足的部分由商业
  • 学习Spring必学的Java基础知识(5)—注解 bijian1013 javaspring
            文章来源：http://www.iteye.com/topic/1123823，整理在我的博客有两个目的：一个是原文确实很不错，通俗易懂，督促自已将博主的这一系列关于Spring文章都学完；另一个原因是为免原文被博主删除，在此记录，方便以后查找阅读。           有必要对
  • 【Struts2一】Struts2 Hello World bit1129 Hello world
    Struts2 Hello World应用的基本步骤 创建Struts2的Hello World应用，包括如下几步： 1.配置web.xml 2.创建Action 3.创建struts.xml，配置Action 4.启动web server，通过浏览器访问   配置web.xml <?xml version="1.0" encoding="
  • 【Avro二】Avro RPC框架 bit1129 rpc
    1. Avro RPC简介 1.1. RPC RPC逻辑上分为二层，一是传输层，负责网络通信；二是协议层，将数据按照一定协议格式打包和解包 从序列化方式来看，Apache Thrift 和Google的Protocol Buffers和Avro应该是属于同一个级别的框架，都能跨语言，性能优秀，数据精简，但是Avro的动态模式（不用生成代码，而且性能很好）这个特点让人非常喜欢，比较适合R
  • lua　set get cookie ronin47 lua cookie
    lua: local access_token = ngx.var.cookie_SGAccessToken if access_token then ngx.header["Set-Cookie"] = "SGAccessToken="..access_token.."; path=/;Max-Age=3000" end
  • java-打印不大于N的质数 bylijinnan java
    public class PrimeNumber { /** * 寻找不大于N的质数 */ public static void main(String[] args) { int n=100; PrimeNumber pn=new PrimeNumber(); pn.printPrimeNumber(n); System.out.print
  • Spring源码学习-PropertyPlaceholderHelper bylijinnan javaspring
    今天在看Spring 3.0.0.RELEASE的源码，发现PropertyPlaceholderHelper的一个bug 当时觉得奇怪，上网一搜，果然是个bug，不过早就有人发现了，且已经修复： 详见： http://forum.spring.io/forum/spring-projects/container/88107-propertyplaceholderhelper-bug
  • [逻辑与拓扑]布尔逻辑与拓扑结构的结合会产生什么? comsci 拓扑
       如果我们已经在一个工作流的节点中嵌入了可以进行逻辑推理的代码,那么成百上千个这样的节点如果组成一个拓扑网络,而这个网络是可以自动遍历的,非线性的拓扑计算模型和节点内部的布尔逻辑处理的结合,会产生什么样的结果呢?    是否可以形成一种新的模糊语言识别和处理模型呢?  大家有兴趣可以试试,用软件搞这些有个好处,就是花钱比较少,就算不成
  • ITEYE 都换百度推广了 cuisuqiang GoogleAdSense百度推广广告外快
    以前ITEYE的广告都是谷歌的Google AdSense，现在都换成百度推广了。   为什么个人博客设置里面还是Google AdSense呢？   都知道Google AdSense不好申请，这在ITEYE上也不是讨论了一两天了，强烈建议ITEYE换掉Google AdSense。至少，用一个好申请的吧。   什么时候能从ITEYE上来点外快，哪怕少点
  • 新浪微博技术架构分析 dalan_123 新浪微博架构
    新浪微博在短短一年时间内从零发展到五千万用户，我们的基层架构也发展了几个版本。第一版就是是非常快的，我们可以非常快的实现我们的模块。我们看一下技术特点，微博这个产品从架构上来分析，它需要解决的是发表和订阅的问题。我们第一版采用的是推的消息模式，假如说我们一个明星用户他有10万个粉丝，那就是说用户发表一条微博的时候，我们把这个微博消息攒成10万份，这样就是很简单了，第一版的架构实际上就是这两行字。第
  • 玩转ARP攻击 dcj3sjt126com r
    我写这片文章只是想让你明白深刻理解某一协议的好处。高手免看。如果有人利用这片文章所做的一切事情，盖不负责。 网上关于ARP的资料已经很多了，就不用我都说了。 用某一位高手的话来说，“我们能做的事情很多，唯一受限制的是我们的创造力和想象力”。 ARP也是如此。 以下讨论的机子有 一个要攻击的机子：10.5.4.178 硬件地址：52:54:4C:98
  • PHP编码规范 dcj3sjt126com 编码规范
    一、文件格式 1. 对于只含有 php 代码的文件，我们将在文件结尾处忽略掉 "?>" 。这是为了防止多余的空格或者其它字符影响到代码。例如：<?php$foo = 'foo';2. 缩进应该能够反映出代码的逻辑结果，尽量使用四个空格，禁止使用制表符TAB，因为这样能够保证有跨客户端编程器软件的灵活性。例
  • linux 脱机管理（nohup） eksliang linux nohupnohup
    脱机管理 nohup 转载请出自出处：http://eksliang.iteye.com/blog/2166699 nohup可以让你在脱机或者注销系统后，还能够让工作继续进行。他的语法如下 nohup [命令与参数] --在终端机前台工作 nohup [命令与参数] & --在终端机后台工作   但是这个命令需要注意的是，nohup并不支持bash的内置命令，所
  • BusinessObjects Enterprise Java SDK greemranqq javaBOSAPCrystal Reports
    最近项目用到oracle_ADF  从SAP/BO 上调用 水晶报表，资料比较少，我做一个简单的分享，给和我一样的新手 提供更多的便利。   首先，我是尝试用JAVA JSP 去访问的。   官方API：http://devlibrary.businessobjects.com/BusinessObjectsxi/en/en/BOE_SDK/boesdk_ja
  • 系统负载剧变下的管控策略 iamzhongyong 高并发
    假如目前的系统有100台机器，能够支撑每天1亿的点击量（这个就简单比喻一下），然后系统流量剧变了要，我如何应对，系统有那些策略可以处理，这里总结了一下之前的一些做法。 1、水平扩展 这个最容易理解，加机器，这样的话对于系统刚刚开始的伸缩性设计要求比较高，能够非常灵活的添加机器，来应对流量的变化。 2、系统分组 假如系统服务的业务不同，有优先级高的，有优先级低的，那就让不同的业务调用提前分组
  • BitTorrent DHT 协议中文翻译 justjavac bit
    前言 做了一个磁力链接和BT种子的搜索引擎 {Magnet & Torrent}，因此把 DHT 协议重新看了一遍。 BEP: 5Title: DHT ProtocolVersion: 3dec52cb3ae103ce22358e3894b31cad47a6f22bLast-Modified: Tue Apr 2 16:51:45 2013 -070
  • Ubuntu下Java环境的搭建 macroli java工作ubuntu
    配置命令： 　　$sudo apt-get install ubuntu-restricted-extras 　　再运行如下命令： 　　$sudo apt-get install sun-java6-jdk 　　待安装完毕后选择默认Java. 　　$sudo update- alternatives --config java 　　安装过程提示选择，输入“2”即可，然后按回车键确定。
  • js字符串转日期（兼容IE所有版本） qiaolevip TODateStringIE
    /** * 字符串转时间（yyyy-MM-dd HH:mm:ss） * result （分钟） */ stringToDate : function(fDate){ var fullDate = fDate.split(" ")[0].split("-"); var fullTime = fDate.split("
  • 【数据挖掘学习】关联规则算法Apriori的学习与SQL简单实现购物篮分析 superlxw1234 sql数据挖掘关联规则
    关联规则挖掘用于寻找给定数据集中项之间的有趣的关联或相关关系。 关联规则揭示了数据项间的未知的依赖关系，根据所挖掘的关联关系，可以从一个数据对象的信息来推断另一个数据对象的信息。 例如购物篮分析。牛奶 ⇒ 面包 [支持度：3%，置信度：40%] 支持度3%：意味3%顾客同时购买牛奶和面包。 置信度40%：意味购买牛奶的顾客40%也购买面包。 规则的支持度和置信度是两个规则兴
  • Spring 5.0 的系统需求，期待你的反馈 wiselyman spring
                   Spring 5.0将在2016年发布。Spring5.0将支持JDK 9。          Spring 5.0的特性计划还在工作中，请保持关注，所以作者希望从使用者得到关于Spring 5.0系统需求方面的反馈。  
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他