单片机教学打铃控制器C语言

最新推荐文章于 2021-05-21 03:02:09 发布
最新推荐文章于 2021-05-21 03:02:09 发布
阅读量1.1k 收藏 7
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 单片机 文章标签： c 语言 delay timer null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/fishtangjinfu/article/details/2256698
本设计介绍了一款基于AT89S52单片机的智能教学楼打铃控制系统，通过按键进行时间及闹铃设置，利用AT24C02存储设置的数据，并实现了动态扫描显示当前时间和已设定的闹铃时间。该系统还具备闹铃增加、删除等功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

/*
            湖南师范大学工学院课程设计    单片机教学打铃控制器
    芯      片：AT89S52
    晶      振：频率12MHz
    按键说明：
              BellSet   P1^0//时间设置
              TimeSet   P1^1//闹铃设置
              LeftMove  P1^2//向左移动
              Add          P1^3//数据增加
              Sub        P1^4//数据减小
              RightMove P1^5//向右移动
              ESC        P1^6//取消
              Enter      P1^7//确定

*/
#include "AT89X52.H"
#include "intrins.h"


#define A24C02W 0xa0//24C02的写地址
#define A24C02R  0xa1//24C02的读地址

unsigned char TimeData[]={0,0,0};//时钟数据
unsigned char BellDataH[40];//40个闹铃点(时)
unsigned char BellDataL[40];//40个闹铃点(分)
unsigned char BellCount=0;//闹铃总数
unsigned char counter=0;
unsigned char I2cStartB=0xaa;//I2c开始标志字
unsigned char I2cEndB=0x55;//I2c结束标志字
unsigned char RayFlag1=0;//秒闪标志1
sbit RayFlag=P3^1;//秒闪
sbit RayFlag2=P3^0;//秒闪标志2
sbit AlarmSingal=P3^4;//闹铃信号
sbit SDA=P3^2;//I2C BUS数据
sbit SCL=P3^3;//I2C BUS时钟

/*
void Timer1(void)interrupt 3 using 1
unsigned char BCD_to_Text(unsigned char Data)
unsigned char GetClockBit(unsigned char ShowBit)
void Delay(unsigned char count)
void D_Scan(unsigned char *ShowAddress,unsigned char FlagBit)
unsigned char GetKey()
void I2cWait()
void I2cStart()
void I2cStop()
void I2cSend(unsigned char ByteData)
unsigned char I2cReceive()
void I2cWrite24C02(unsigned char I2c24C02Addr,unsigned char I2c24C02Data)
unsigned char I2cRead24C02(unsigned char I2c24C02Addr)
void Init24C02(void)
void Order(void)
void BellSet(void)
void TimeSet()

*/
//--------------------------定义I2C接口子程序-------------------------
/*
I2C特殊字节定义
*/
void I2cWait()//等待
{
    _nop_();
    _nop_();
}
   
void I2cStart()//开始
{   
    SDA=1;
    SCL=1;
    I2cWait();
    SDA=0;
    I2cWait();
    SCL=0;
}

void I2cStop()//停止
{
    SDA=0;
    I2cWait();
    SCL=1;
    I2cWait();
    SDA=1;
}
void I2cSend(unsigned char ByteData)//发送
{
    unsigned char i;
    for(i=0;i<8;i++)
    {
        if(ByteData&0x80)
            SDA=1;
        else
            SDA=0;
        ByteData<<=1;
        I2cWait();
        SCL=1;
        I2cWait();
        SCL=0;
        I2cWait();
    }
    SDA=1;
    I2cWait();
    SCL=1;
    I2cWait();
    SCL=0;
    I2cWait();
}

unsigned char I2cReceive()//接收
{
    unsigned char i;
    unsigned char ByteData=0;
    for(i=0;i<8;i++)
    {
        SCL=1;
        I2cWait();
        ByteData<<=1;
        if(SDA)ByteData++;
        SCL=0;
        I2cWait();
    }
    SDA=1;
    I2cWait();
    SCL=1;
    I2cWait();
    SCL=0;
    I2cWait();
    return ByteData;
}
//--------------------------声明AT24C02的读写子程序-------------------
void I2cWrite24C02(unsigned char I2c24C02Addr,unsigned char I2c24C02Data)//写
{
    I2cStart();
    I2cSend(A24C02W);
    I2cSend(I2c24C02Addr);
    I2cSend(I2c24C02Data);
    I2cStop();
}

unsigned char I2cRead24C02(unsigned char I2c24C02Addr)//读
{
    unsigned char Data;
    I2cStart();
    I2cSend(A24C02W);
    I2cSend(I2c24C02Addr);
    I2cStart();
    I2cSend(A24C02R);
    Data=I2cReceive();
    I2cStop();
    return Data;
}
//-------------------------初始化24C02-----------------------------
void Init24C02(void)
{
    unsigned char i,j;
    unsigned char StartByte=I2cRead24C02(0);
    j=1;
    if(StartByte==I2cStartB)
        for(i=0;i<40;i++)
        {
            if(I2cRead24C02(j)==I2cEndB)break;
            BellDataH[i]=I2cRead24C02(j++);
            BellDataL[i]=I2cRead24C02(j++);
            BellCount++;
        }
    else
        {
            I2cWrite24C02(0,I2cStartB);
            I2cWrite24C02(1,I2cEndB);
        }
}




//---------------------T1中断，产生时钟-------------------------------
void Timer1(void)interrupt 3 using 1
{
    TH1=0x3c;
    TL1=0xb0;
    if(counter%10==0)
    {
        RayFlag2=~RayFlag2;
        if(RayFlag1)RayFlag=0;
        else RayFlag=~RayFlag;
    }
    if(counter==20)
    {
        counter=1;
        if(TimeData[0]==59)
        {
            TimeData[0]=0;
            if(TimeData[1]==59)
            {
                TimeData[1]=0;
                if(TimeData[2]==23)
                {
                    TimeData[2]=0;
                }
                else TimeData[2]++;//时
            }
            else TimeData[1]++;//分
        }
        else TimeData[0]++;//秒
    }
    else counter++;   
}
//------------------BCD码转换成字形码的程序-----------------------------
unsigned char BCD_to_Text(unsigned char Data)
{
    switch(Data)
    {
        case 0:return 0x3f;
        case 1:return 0x06;
        case 2:return 0x5b;
        case 3:return 0x4f;
        case 4:return 0xe6;
        case 5:return 0xed;
        case 6:return 0xfd;
        case 7:return 0x07;
        case 8:return 0xff;
        case 9:return 0xef;
    }
}

//-----------------------------得到位地址的程序-------------------------
unsigned char GetClockBit(unsigned char ShowBit)
{
    switch(ShowBit)
    {
        case 0:return 0xdf;
        case 1:return 0xef;
        case 2:return 0xf7;
        case 3:return 0xfb;
        case 4:return 0xfd;
        case 5:return 0xfe;
    }
}
//---------------------延时count个ms的程序-------------------------
void Delay(unsigned char count)
{
    unsigned char i;
    while(count--)
    {
        for(i=0;i<123;i++)
        ;
    }
}
//-----------------------动态扫描的程序-------------------------------
void D_Scan(unsigned char *ShowAddress,unsigned char FlagBit)
{
    unsigned char ShowBit;
    unsigned char Show;
    for(ShowBit=0;ShowBit<6;ShowBit++)
    {
        if(FlagBit!=5)
        {
            switch(ShowBit)
            {
                case 0:Show=BCD_to_Text((*ShowAddress)%10);break;
                case 1:Show=BCD_to_Text((*ShowAddress)/10);break;
                case 2:Show=BCD_to_Text((*(ShowAddress+1))%10);break;
                case 3:Show=BCD_to_Text((*(ShowAddress+1))/10);break;
                case 4:Show=BCD_to_Text((*(ShowAddress+2))%10);break;
                case 5:Show=BCD_to_Text((*(ShowAddress+2))/10);break;
            }
        }
        P2=0xff;
        switch(FlagBit)
        {
            case 0:P0=Show;break;
            case 1://设秒闪动
                    if(RayFlag2 && (ShowBit==0||ShowBit==1))P0=0x40;
                    else P0=Show;
                    break;
            case 2://设分闪动
                    if(RayFlag2 && (ShowBit==2||ShowBit==3))P0=0x40;
                    else P0=Show;
                    break;
            case 3://设时闪动
                    if(RayFlag2 && (ShowBit==4||ShowBit==5))P0=0x40;
                    else P0=Show;
                    break;
            case 4://调闹铃时的闪动
                    if(RayFlag2)P0=0x40;
                    else P0=Show;
                    break;
            case 5://调闹铃时的显示
                    P0=*(ShowAddress+ShowBit);
                    break;
        }   
        P2=GetClockBit(ShowBit);
        Delay(1);
    }
}

//----------------得到键盘值的程序----------------------------------
unsigned char GetKey()
{
    switch(P1)
    {
        case 0xff:return 0;
        case 0xfe:return 1;
        case 0xfd:return 2;
        case 0xfb:return 3;
        case 0xf7:return 4;
        case 0xef:return 5;
        case 0xdf:return 6;
        case 0xbf:return 7;
        case 0x7f:return 8;
    }
}



//-------------------排序的程序------------------------------------
void Order(void)
{
    unsigned char i,j,t;
    for(i=0;i<BellCount;i++)
        for(j=0;j<BellCount-i-1;j++)
            {
                if(BellDataH[j]>BellDataH[j+1])
                    {
                        t=BellDataH[j];
                        BellDataH[j]=BellDataH[j+1];
                        BellDataH[j+1]=t;
                        t=BellDataL[j];
                        BellDataL[j]=BellDataL[j+1];
                        BellDataL[j+1]=t;
                    }
                else if(BellDataH[j]==BellDataH[j+1])
                        if(BellDataL[j]>BellDataL[j+1])
                            {
                                t=BellDataL[j];
                                BellDataL[j]=BellDataL[j+1];
                                BellDataL[j+1]=t;
                            }
            }   
}

//---------------------------闹铃设置--------------------------------
void BellSet(void)
{
    unsigned char Null[]={0x00,0x38,0x38,0x3e,0x37,0x00};//"Null"的字形码
    unsigned char ShowRing[3];
    unsigned char NowKey;
    unsigned char i,j=1;
    unsigned char BeforKey=0xff;
    unsigned char KeyCount=0;
    unsigned char FlagBit=3;
    unsigned char ShowBellCount=0;
    unsigned char count1=0x40;//无操作时的时间控制
    unsigned char count2=0xff;//无操作时的时间控制
    RayFlag1=1;
    ShowRing[0]=BellDataL[ShowBellCount];
    ShowRing[1]=BellDataH[ShowBellCount];
    ShowRing[2]=ShowBellCount;
    while(1)
    {
        if(BellCount==0)
            D_Scan(Null,5);
        else
            D_Scan(ShowRing,FlagBit);
        if(KeyCount==2)
        {
            KeyCount=0;
            NowKey=GetKey();
            if(NowKey!=BeforKey)
            {
                count1=0x40;
                count2=0xff;
                switch(NowKey)
                {
                    case 1://增加一个闹铃
                            if(BellCount!=40 && FlagBit==4)
                            {
                                BellDataH[BellCount]=BellDataL[BellCount]=0;   
                                ShowBellCount=BellCount++;
                            }
                            if(BellCount==0)
                            {
                                BellDataH[0]=BellDataL[0]=0;
                                BellCount++;
                            }
                            ShowRing[0]=BellDataL[ShowBellCount];
                            ShowRing[1]=BellDataH[ShowBellCount];
                            ShowRing[2]=ShowBellCount;
                            break;
                    case 2://删除一个闹铃
                            if(BellCount!=0 && FlagBit==4)
                            {
                                if(BellCount==1)
                                {
                                    BellDataH[0]=BellDataL[0]=0;
                                }
                                else
                                    {
                                        for(i=ShowBellCount;i<BellCount;i++)
                                        {
                                            BellDataH[i]=BellDataH[i+1];
                                            BellDataL[i]=BellDataL[i+1];
                                        }
                                        BellDataH[i]=BellDataL[i]=0;
                                    }
                                BellCount--;   
                                if(BellCount==ShowBellCount)
                                    ShowBellCount--;
                                ShowRing[0]=BellDataL[ShowBellCount];
                                ShowRing[1]=BellDataH[ShowBellCount];
                                ShowRing[2]=ShowBellCount;
                            }
                            break;

                    case 3://左移
                            if(BellCount!=0)
                            {
                                if(FlagBit==4)FlagBit=1;
                                else FlagBit++;
                            }
                            break;
                    case 4://闹铃时间增
                            switch(FlagBit)
                            {
                                case 1:
                                        if(ShowRing[0]==59)
                                            ShowRing[0]=0;
                                        else
                                            ShowRing[0]++;
                                        BellDataL[ShowBellCount]=ShowRing[0];
                                        break;
                                case 2:
                                        if(ShowRing[1]==23)
                                            ShowRing[1]=0;
                                        else
                                            ShowRing[1]++;
                                        BellDataH[ShowBellCount]=ShowRing[1];
                                        break;
                                case 3:
                                        if(ShowBellCount==BellCount-1)
                                            ShowBellCount=0;
                                        else
                                            ShowBellCount++;
                                        ShowRing[0]=BellDataL[ShowBellCount];
                                        ShowRing[1]=BellDataH[ShowBellCount];
                                        ShowRing[2]=ShowBellCount;
                                        break;
                            }
                            break;
                    case 5://闹铃时间减
                            switch(FlagBit)
                            {
                                case 1:
                                        if(ShowRing[0]==0)
                                            ShowRing[0]=59;
                                        else
                                            ShowRing[0]--;
                                        break;
                                case 2:
                                        if(ShowRing[1]==0)
                                            ShowRing[1]=23;
                                        else
                                            ShowRing[1]--;
                                        break;
                                case 3:
                                        if(ShowBellCount==0)
                                            ShowBellCount=BellCount-1;
                                        else
                                            ShowBellCount--;
                                        ShowRing[0]=BellDataL[ShowBellCount];
                                        ShowRing[1]=BellDataH[ShowBellCount];
                                        ShowRing[2]=ShowBellCount;
                                        break;
                            }
                            break;
                    case 6://右移
                            if(BellCount!=0)
                            {
                                if(FlagBit==1)FlagBit=4;
                                else FlagBit--;
                            }
                            break;
                    case 7://取消
L3:                            j=1;
                            BellCount=0;
                            EA=0;
                            for(i=0;i<40;i++)
                            {
                                if(I2cRead24C02(j)==I2cEndB)break;
                                BellDataH[i]=I2cRead24C02(j++);
                                BellDataL[i]=I2cRead24C02(j++);
                                BellCount++;
                            }
                            EA=1;
                            goto L2;
                    case 8://确定
                            j=1;
                            BellDataL[ShowBellCount]=ShowRing[0];
                            BellDataH[ShowBellCount]=ShowRing[1];
                            Order();//排序
                            for(i=0;i<BellCount;i++)
                            {
                                EA=0;
                                I2cWrite24C02(j++,BellDataH[i]);
                                EA=1;
                                D_Scan(ShowRing,FlagBit);
                                EA=0;
                                I2cWrite24C02(j++,BellDataL[i]);
                                EA=1;
                                D_Scan(ShowRing,FlagBit);
                            }
                            EA=0;
                            I2cWrite24C02(j,I2cEndB);
                            EA=1;
                            if(BellCount==0)
                                D_Scan(Null,5);
                            else
                                D_Scan(ShowRing,FlagBit);
                            goto L2;
                               
                } 
            }
            BeforKey=NowKey;
            count2--;
            if(count2==0)
            {
                count2=0x40;
                count1--;
                if(count1==0)
                    goto L3;
            }
        }
        else KeyCount++;
    }
L2:RayFlag1=0;
}

//-------------时间设置的程序--------------------------------------------
void TimeSet()
{
    unsigned char S_Flag=1;
    unsigned char M_Flag=1;
    unsigned char H_Flag=1;
    unsigned char count1=0x40;//无操作时的时间控制
    unsigned char count2=0xff;//无操作时的时间控制
    unsigned char NowKey=0xff;
    unsigned char BeforKey=0xff;
    unsigned char KeyCount=0;
    unsigned char FlagBit=1;
    unsigned char LS_TimeData[3];
    LS_TimeData[2]=TimeData[2];
    LS_TimeData[1]=TimeData[1];
    LS_TimeData[0]=TimeData[0];
    while(1)
    {
        if(S_Flag)LS_TimeData[0]=TimeData[0];
        if(M_Flag)LS_TimeData[1]=TimeData[1];
        if(H_Flag)LS_TimeData[2]=TimeData[2];
        D_Scan(LS_TimeData,FlagBit);//动态扫描显示
        if(KeyCount==2)
        {
       
            KeyCount=0;
            NowKey=GetKey();
            if(NowKey!=BeforKey)
            {
                count1=0x40;
                count2=0xff;
                switch(GetKey())
                {
                    case 3://向左移动
                            if(FlagBit==3)FlagBit=1;
                            else FlagBit++;
                            break;
                    case 4://增加
                            switch(FlagBit)
                            {
                                case 1://秒增加
                                        if(LS_TimeData[0]==59)
                                            LS_TimeData[0]=0;
                                        else LS_TimeData[0]++;   
                                        S_Flag=0;
                                        break;
                                case 2://分增加
                                        if(LS_TimeData[1]==59)
                                            LS_TimeData[1]=0;
                                        else LS_TimeData[1]++;
                                        M_Flag=0;
                                        break;
                                case 3://时增加
                                        if(LS_TimeData[2]==23)
                                            LS_TimeData[2]=0;
                                        else LS_TimeData[2]++;
                                        H_Flag=0;
                                        break;
                            }
                            break;
                    case 5://减小
                            switch(FlagBit)
                            {
                                case 1://秒减小
                                        if(LS_TimeData[0]==0)
                                            LS_TimeData[0]=59;
                                        else LS_TimeData[0]--;
                                        S_Flag=0;
                                        break;
                                case 2://分减小
                                        if(LS_TimeData[1]==0)
                                            LS_TimeData[1]=59;
                                        else LS_TimeData[1]--;
                                        M_Flag=0;
                                        break;
                                case 3://时减小
                                        if(LS_TimeData[2]==0)
                                            LS_TimeData[2]=23;
                                        else LS_TimeData[2]--;
                                        H_Flag=0;
                                        break;
                            }
                            break;
                    case 6://向右移动
                            if(FlagBit==1)FlagBit=3;
                            else FlagBit--;
                            break;
                    case 7://取消
                            goto L1;
                    case 8://确定
                            TimeData[2]=LS_TimeData[2];
                            TimeData[1]=LS_TimeData[1];
                            TimeData[0]=LS_TimeData[0];
                            goto L1;
                }
            }
            BeforKey=NowKey;
            count2--;
            if(count2==0)
            {
                count2=0x40;
                count1--;
                if(count1==0)
                    goto L1;
            }
        }
        else KeyCount++;
    }
L1:;
}




//----------------------主程序-----------------------------------------------
void main()
{
    unsigned char NowKey;
    unsigned char BeforKey=0xff;
    unsigned char KeyCount=0;
    unsigned char i=1;
    AlarmSingal=0;
    RayFlag=1;
    RayFlag2=1;
    Init24C02();//读24C02
    TMOD=0x10;//设置T1
    EA=1;
    ET1=1;
    PT1=1;
    TH1=0x3c;
    TL1=0xb0;
    TR1=1;
    while(1)
    {   
        D_Scan(TimeData,0);//动态扫描
        //闹铃监视
        for(i=0;i<BellCount;i++)
        {
            if((BellDataH[i]==TimeData[2]) && (BellDataL[i]==TimeData[1]))
            {
                AlarmSingal=1;
                break;
            }
            else AlarmSingal=0;
        }
        //按键控制
        if(KeyCount==2)
        {
       
            KeyCount=0;
            NowKey=GetKey();
            if(NowKey!=BeforKey)
            {
                switch (NowKey)
                {
                    case 1:
                            TimeSet();
                            break;
                    case 2:
                            AlarmSingal=0;
                            BellSet();   
                            break;
                    default:
                            break;
                }
            }
            BeforKey=NowKey;
        }
        else KeyCount++;
    }
}

 
19、基于STM32的电子打铃器
行走的皮卡丘
12-28 2136
当今时代是一个新技术层出不穷的时代，在电子领域尤其是自动化智能控制领域，传统的分立元件或数字逻辑电路构成的控制系统，正以前所未有的速度被单片机智能控制系统所取代。嵌入式具有体积小、功能强、成本低、应用面广等优点，可以说，智能控制与自动控制的核心就是单片机。目前，一个学习与应用嵌入式的高潮正在工厂、学校及企事业单位大规模地兴起。学习嵌入式的最有效的方法就是理论与实践并重，本文用STM32设计的一个教学电子打铃系统。本次设计采用STM32单片机，在按键的作用下可以进行调打铃次数、倒计时、复位功能。
4、☛基于STM32的电子打铃器√★☆
行走的皮卡丘
08-10 1729
4、基于STM32的电子打铃器 文章目录4、基于STM32的电子打铃器Introduction引言1、系统概述1.1、设计任务1.2、设计要求2 、方案设计与论证2.1、芯片选择方案2.2、 系统概述2.3、设计要求2.4、系统总体设计思路2.5、各功能模块程序实现原理分析2.5.1、 显示器模块2.5.2 、按钮控制模块2.5.3、 LED模块3、STM32性能介绍及硬件设计3.1、STM32单片机性能介绍3.2、电子打铃系统硬件设计4、 系统程序4.1、主程序设计如下4.2、 主程序内容4.3 、定时器
电子打铃器设计
01-06
　　1.设计思路 　　　　利用单片机及定时器设计的一个时钟,在每次秒加 1的计时过程中,都与规定的时间作比较,如果相等就进行开关电铃,不等则返回。24小时累加为一天，如果天数大于5天时，电铃也不打铃。 　　2.关键芯片介绍 　　　　AT89C51是一种带4K字节闪存可编程可擦除只读存储器（FPEROM—Flash Programmable and Erasable Read Only Memory）的低电压、高性能CMOS 8位微处理器，俗称单片机。AT89C2051是一种带2K字节闪存可编程可擦除只读存储器的单片机。单片机的可擦除只读存储器可以反复擦除1000次。该器件采用ATMEL高密度非易失存储器制造技术制造，与工业标准的MCS-51指令集和输出管脚相兼容。由于将多功能8位CPU和闪烁存储器组合在单个芯片中，ATMEL的AT89C51是一种高效微控制器，AT89C2051是它的一种精简版本。AT89C单片机为很多嵌入式控制系统提供了一种灵活性高且价廉的方案。外形及引脚排列如图所示：
单片机32点打铃器设计
04-24
刚找到的一个关于打铃器的设计，分享一下~~~~
【单片机】单片机课程设计（测温打铃）附完整代码和电路图
热门推荐
九芒星的博客
12-29 1万+
测温打铃附代码和电路图前言一、测温打铃是什么？二、具体实现1.电路图2.代码程序效果图 前言 一、测温打铃是什么？ 测温打铃是在单片机的基础上实现的一种温度报警装置。它可以通过自己设定报警温度，当温度传感器的温度达到报警温度发出报警声。（本项目添加生日快乐的报警音乐）有想法的可以自己动手实践，做一个真正的单片机实体项目。 二、具体实现 1.电路图 电路图首先要了解需要哪些元件，我在本项目中添加了微调电容、外部晶振、温度传感器、LCD显示屏、排阻、三极管、蜂鸣器、AT89C52。下面是具体电路图。 2..
51单片机自动打铃器c语言,基于51单片机对自动打铃系统的设计
weixin_39723010的博客
05-21 1438
描述51单片机自动打铃C语言程序：#include “reg51.h”#include “intrins.h” #define uchar unsigned char #define uint unsigned intuchar code DSY_CODE［］ = {0xc0，0xf9，0xa4，0xb0，0x99，0x92，0x82，0xf8，0x80，0x90，0xff};//共阴极总段//u...
c语言打铃器单片机程序,51单片机自动打铃C语言程序
weixin_28864485的博客
05-18 733
51单片机自动打铃C语言程序:#include "reg51.h"#include "intrins.h" #define uchar unsigned ｃｈａｒ #define uint unsigned intuchar code DSY_CODE[] = {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0xff};//共阴极总段//u...
51单片机自动打铃器c语言,如何利用51单片机实现自动打铃
weixin_39879881的博客
05-21 815
描述51单片机自动打铃C语言程序：#include “reg51.h”#include “intrins.h” #define uchar unsigned char #define uint unsigned intuchar code DSY_CODE［］ = {0xc0，0xf9，0xa4，0xb0，0x99，0x92，0x82，0xf8，0x80，0x90，0xff};//共阴极总段//u...
c语言打铃器单片机程序,基于单片机的自动打铃器的设计
weixin_29641609的博客
05-18 881
基于单片机的自动打铃器的设计-电气信息学院毕业设计目 录摘要IAbstractII第一章绪论11.1单片机设计的目的和意义11.2单片机发展现状和前景展望11.2.1课题发展现状11.2.2课题前景展望21.3Protel 99 SE概述21.3.1Protel 99 SE的组成31.3.2Protel 99 SE的应用41.3.3电路板的设计步骤6第二章单元模块的设计82.1电源模块82.2单...
c语言打铃器单片机程序,基于单片机的自动打铃器.doc
weixin_35967330的博客
05-18 624
第 PAGE 3 页单片机实训指导书制作自动打铃器实习目的综合应用定时器、中断、数码显示等单片机知识。掌握打铃器程序的设计和调试方法。原理说明线路如图1所示：功能键?功能键?330*7 ΩP1.0P1.6P2.0P2.5IC1g f e d c b aIC2移位键20032003+5V+5V加1键加1键图1 原理图图1 原理图由图可知，IC3(单片机)的P2.0至P2.5口为扫描...
基于51单片机的教学打铃控制器的毕业设计.doc
最新发布
08-09
基于51单片机的教学打铃控制器是一项应用于教育机构的自动化控制系统设计项目，其目的在于设计一种能够自动进行打铃操作的装置，以实现学校或其他教育机构的定时打铃功能。该项目主要由以下几个部分构成： 首先，...
基于51单片机的教学打铃控制器的设计论文正文.doc
06-12
本文将探讨如何设计一个基于51单片机的教学打铃控制器，重点在于系统设计、编程与实现过程。 首先，设计基于51单片机的教学打铃控制器必须具备以下功能：能够获取并设定时间，显示当前时间及预设时间，比对设定时间...
基于51单片机电子打铃器设计
04-06
51单片机作为早期的一种微控制器，在电子设计领域有着广泛的应用基础，尤其是其C51内核的单片机STC89C52，因具有成本低廉、编程简单、接口丰富等特点，非常适合应用于电子打铃器的设计。 设计的基本思路是利用STC89...
单片机教学打铃控制器设计与程序实现
在湖南涉外经济学院的单片机教学中，一个重要的课程设计项目是单片机教学打铃控制器程序设计。这个设计旨在让学生实践并掌握单片机技术，通过实际操作来实现一个智能化的打铃系统。以下是该设计的主要知识点： 1. *...
stm32无源蜂鸣器定时器_STM32无源蜂鸣器播放音乐
weixin_32288959的博客
12-24 2684
1.STM32产生PWM波驱动无源蜂鸣器使其发声1)查看原理图，找到对应引脚(我这里时PA1)2)打开CubeMax,输入自己芯片的类型确定后，配置好系统时钟RCC,我这里是80Mhz,找到相应引脚PA1设置为GPIO_Output模式(用来切换引脚状态，使蜂鸣器发声),3)设置定时器我这里用TM22.音乐播放原理原理：给无源蜂鸣器输入不同频率的PWM波(构成不同音调) 让PWM波持续不同长度的...
Keil C51教程
04-07 4272
第三课 C51数据类型 作者：    来源：本站原创    点击数： 3477   更新时间：2007年07月18日   
点阵式LED“0－9”数字显示技术
04-07 2497
1． 实验任务 利用8X8点阵显示数字0到9的数字。2． 电路原理图 <v:shapetype id="_x0000_t75"coordsize="21600,21600" o:spt="75" o:preferrelative="t" path="m@4@5l@4@11@9@11@9@5xe"filled="f" stroked="f">
4×4键盘及8位数码管显示构成的电子密码锁
04-07 2217
1．      实验任务 用4×4组成0－9数字键及确认键。用8位数码管组成显示电路提示信息，当输入密码时，只显示“8.”，当密码位数输入完毕按下确认键时，对输入的密码与设定的密码进行比较，若密码正确，则门开，此处用LED发光二极管亮一秒钟做为提示，同时发出“叮咚”声；若密码不正确，禁止按键输入3秒，同时发出“嘀、嘀”报警声；若在3秒之内仍有按键按下，则禁止按键输入3秒
单片机教学：打铃控制器系统设计与PCB图解析
- 整体电路图：通过“单片机教学打铃控制器整体电路图.bmp”，我们可以分析和学习单片机打铃控制器的设计原理、电路连接以及各个组成部分的功能。 - PCB设计文件：文件“单片机教学打铃控制器.ddb”为PCB设计文件...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值