基于51单片机电动自行车车速报警系统proteus仿真原理图程序

已于 2023-10-02 14:17:04 修改
阅读量1.5k 收藏 4
点赞数 1
文章标签： 单片机
于 2022-12-11 18:59:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jimo167913/article/details/128277409
版权

功能：
0.本项目采用STC89C52作为单片机系统的控制MCU
1.LCD1602液晶分三种显示模式
a)显示实时速度和本次里程
b)显示当前时间
c)显示报警速度和总里程
2.超过报警速度将声光报警
3.功能按键介绍
a显示状态下:
'上’键——电机速度+1 '下’键——电机速度-1
'设置’键——电机启动/暂停
'切换’键——切换显示状态
b显示状态下:
'设置’键——进入时间设置
'切换’键——切换显示状态
*时间设置状态
'上’键——加1 '下’键——减1
'左’键/'右’键——更改设置坐标
'切换’键——确定
c显示状态下:
'设置’键——进入速度设置
'切换’键——切换显示状态
*报警速度设置状态
'上’键——加1 '下’键——减1
'左’键/'右’键——更改设置选项
'切换’键——确定
*总里程设置状态
'上’键/'下’键——清零
'左’键/'右’键——更改设置选项
'切换’键——确定
4.采用DC002作为电源接口可直接输入5V给整个系统供电

原理图：
在这里插入图片描述

PCB ：
在这里插入图片描述

主程序：

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

#define DIAMETER 20 //直径，单位mm

float distance = 0; //单位m
float totalDistBuf = 0; //单位m
float rate = 0; //单位km/h
float totalDist = 0; //单位km
unsigned char rateAlarm = 30; //单位km/h
unsigned char second = 0; 
unsigned char minute = 0; 
unsigned long pulseCnt = 0;
bit dispFlag = 1;
bit setTimeFlag = 0;
bit setAlarmFlag = 0;
bit motorFlag = 0;
bit refreshFlag = 0;
bit writeFlag = 0;
bit isNewFlag = 1;
unsigned char pwmValue = 3;
unsigned char setIndex = 0;

enum{
    DISP_RATE_MODE, DISP_TIME_MODE, SET_ALARM_MODE
} dispMode;

void main()
{
    //初始化
    LCD_Init();
    DS1302_Init();
    EEPROM_Init();

    //EEPROM_WriteByte(IS_NEW_ADDR, 1); //将芯片设为新芯片

    ReadEEPROM();
    if (isNewFlag != 0) //新芯片
    {
        EEPROM_WriteByte(IS_NEW_ADDR, 0);
        
        //给出初始值
        rateAlarm = 30;
        totalDist = 0;

        WriteEEPROM();
    }

    DS1302_ReadTime();

    Timer0_Init();
    Timer1_Init();
    EXT1_Init();

    //开机显示
    LCD_DispStr(0, 0, "    Welcome!    ");
    DelayS(2);
    LCD_Clear();

    while(1)
    {
        //每秒钟更新数据
        if (refreshFlag == 1)
        {
            distance = distance + DIAMETER * 2 * 3.14 * (float)pulseCnt / 1000 ; //单位m
            totalDist = totalDist + DIAMETER * 2 * 3.14 * (float)pulseCnt / 1000; //单位km
            rate = 3.6 * DIAMETER * 2 * 3.14 * (float)pulseCnt / 1000; //单位km/h
            pulseCnt = 0;
            EX1 = 1;
            refreshFlag = 0;
        }
        
        //每分钟写一次EEPROM
        if (writeFlag == 1)
        {
            if (totalDist != totalDistBuf) //里程是否发生变化
            {
                WriteEEPROM();
            }
            totalDistBuf = totalDist;
            writeFlag = 0;
        }
        
        //显示函数
        if (dispFlag == 1)
        {
            if (dispMode == DISP_RATE_MODE)
            {
                DispRate();
            }
            else if (dispMode == DISP_TIME_MODE)
            {
                if (setTimeFlag == 0)
                {
                    DS1302_ReadTime();
                    DispTime(setIndex, setTimeFlag);
                }
            }
            else if (dispMode == SET_ALARM_MODE)
            {
                if (setAlarmFlag == 0)
                {
                    // ReadEEPROM();
                    if (totalDist != totalDistBuf)
                    {
                        WriteEEPROM();
                    }
                    totalDistBuf = totalDist;
                    DispAlarm(setIndex, setAlarmFlag);
                }
            }
        }

        //超速报警
        if (rate > rateAlarm)
        {
            BUZZER = 0;
        }
        else
        {
            BUZZER = 1;
        }
        KeyProcess();
    }
}

void ReadEEPROM(void)
{
    isNewFlag    = EEPROM_ReadByte(IS_NEW_ADDR);

    rateAlarm      = EEPROM_ReadByte(IS_NEW_ADDR + 1);
    totalDist      = EEPROM_ReadByte(IS_NEW_ADDR + 2);
    totalDist     = ((unsigned int)totalDist << 8) | EEPROM_ReadByte(IS_NEW_ADDR + 3);
}

void WriteEEPROM(void)
{
    EEPROM_WriteByte(IS_NEW_ADDR + 1, rateAlarm);
    EEPROM_WriteByte(IS_NEW_ADDR + 2, (((unsigned int)totalDist & 0xFF00) >> 8));
    EEPROM_WriteByte(IS_NEW_ADDR + 3, ((unsigned int)totalDist & 0x00FF));
}


void DispAlarm(unsigned char setIndex, bit setAlarmFlag)
{
    static unsigned char xdata dispRow0[16];
    static unsigned char xdata dispRow1[16];

    if (setAlarmFlag == 1)
    {
        LCD_WriteCommand(0x0F, 0);
    }
    else
    {
        LCD_WriteCommand(0x0C, 0);
        LCD_WriteCommand(0x0C, 0);
    }

    sprintf(dispRow0, "Alarm:%6.2fkm/h", (float)rateAlarm);
    sprintf(dispRow1, "Total:%8.2fkm", (float)totalDist / 1000);

    LCD_DispStr(0, 0, dispRow0);
    LCD_DispStr(0, 1, dispRow1);

    switch (setIndex)
    {
        case 1: LCD_LocateXY(8, 0); break;
        case 2: LCD_LocateXY(13, 1); break;
        default: ;
    }
}

void DispRate()
{
    static unsigned char xdata dispRow0[16];
    static unsigned char xdata dispRow1[16];

    sprintf(dispRow0, "Rate:%7.2fkm/h", rate);
    sprintf(dispRow1, "Dist:%9.2fkm", distance / 1000);

    LCD_DispStr(0, 0, dispRow0);
    LCD_DispStr(0, 1, dispRow1);
}

void DispTime(unsigned char setIndex, bit setTimeFlag)
{
    static unsigned char xdata dispRow0[] = "  /  /     ";
    static unsigned char xdata dispRow1[] = "      :  :      ";

    if (setTimeFlag == 1)
    {
        LCD_WriteCommand(0x0F, 0);
    }
    else
    {
        LCD_WriteCommand(0x0C, 0);
        LCD_WriteCommand(0x0C, 0);
    }

    dispRow0[0] = timeBufDec[1] / 10 +'0';
    dispRow0[1] = timeBufDec[1] % 10 +'0';
    dispRow0[3] = timeBufDec[2] / 10 +'0';
    dispRow0[4] = timeBufDec[2] % 10 +'0';
    dispRow0[6] = timeBufDec[3] / 10 +'0';
    dispRow0[7] = timeBufDec[3] % 10 +'0';
    dispRow1[4] = timeBufDec[4] / 10 +'0';
    dispRow1[5] = timeBufDec[4] % 10 +'0';  
    dispRow1[7] = timeBufDec[5] / 10 +'0';
    dispRow1[8] = timeBufDec[5] % 10 +'0';
    dispRow1[10] = timeBufDec[6] / 10 +'0';
    dispRow1[11] = timeBufDec[6] % 10 +'0';

    LCD_DispStr(0, 0, dispRow0);
    LCD_DispStr(0, 1, dispRow1);

    switch (timeBufDec[7])
    {
        case 1: LCD_DispStr(10, 0, " Sun. "); break;
        case 2: LCD_DispStr(10, 0, " Mon. "); break;
        case 3: LCD_DispStr(10, 0, " Tue. "); break;
        case 4: LCD_DispStr(10, 0, " Wed. "); break;
        case 5: LCD_DispStr(10, 0, "Thur. "); break;
        case 6: LCD_DispStr(10, 0, " Fri. "); break;
        case 7: LCD_DispStr(10, 0, " Sat. "); break;
        default: ;
    }

    switch (setIndex)
    {
        case 1: LCD_LocateXY(1 , 0); break;
        case 2: LCD_LocateXY(4 , 0); break;
        case 3: LCD_LocateXY(7 , 0); break;
        case 4: LCD_LocateXY(14, 0); break;
        case 5: LCD_LocateXY(5 , 1); break;
        case 6: LCD_LocateXY(8 , 1); break;
        case 7: LCD_LocateXY(11, 1); break;
        default: ;
    }
}

void KeyProcess()
{
        if (!KEY_SET) //设置键按下
        {
            DelayMs(10);
            if (!KEY_SET)
            {
                if (dispMode == DISP_TIME_MODE)
                {
                    if (setTimeFlag == 0)
                    {
                        setTimeFlag = 1;
                        setIndex = 1;
                        DispTime(setIndex, setTimeFlag);
                    }
                }
                else if(dispMode == SET_ALARM_MODE)
                {
                    if (setAlarmFlag == 0)
                    {
                        setAlarmFlag = 1;
                        setIndex = 1;
                        DispAlarm(setIndex, setAlarmFlag);
                    }
                }
                else
                {
                    motorFlag = ~motorFlag;
                }
            }
            while (!KEY_SET)
                ;
        }

        if (!KEY_UP) //上键按下
        {
            DelayMs(150);
            if (!KEY_UP)
            {
                if (dispMode == DISP_TIME_MODE)
                {
                    if (setTimeFlag == 1)
                    {
                        switch (setIndex)
                        {
                        case 1:
                        {
                            timeBufDec[1]++;
                            if (timeBufDec[1] >= 100)
                            {
                                timeBufDec[1] = 0;
                            }
                            break;
                        }
                        case 2:
                        {
                            timeBufDec[2]++;
                            if (timeBufDec[2] >= 13)
                            {
                                timeBufDec[2] = 1;
                            }
                            break;
                        }
                        case 3:
                        {
                            timeBufDec[3]++;
                            if (timeBufDec[3] >= YDay(timeBufDec[1], timeBufDec[2]) + 1)
                            {
                                timeBufDec[3] = 1;
                            }
                            break;
                        }
                        case 4:
                        {
                            timeBufDec[7]++;
                            if (timeBufDec[7] > 7)
                            {
                                timeBufDec[7] = 1;
                            }
                            break;
                        }
                        case 5:
                        {
                            timeBufDec[4]++;
                            if (timeBufDec[4] >= 24)
                            {
                                timeBufDec[4] = 0;
                            }
                            break;
                        }
                        case 6:
                        {
                            timeBufDec[5]++;
                            if (timeBufDec[5] >= 60)
                            {
                                timeBufDec[5] = 0;
                            }
                            break;
                        }
                        case 7:
                        {
                            timeBufDec[6]++;
                            if (timeBufDec[6] >= 60)
                            {
                                timeBufDec[6] = 0;
                            }
                            break;
                        }
                        default:;
                        }
                        DispTime(setIndex, setTimeFlag);
                    }
                }
                else if (dispMode == SET_ALARM_MODE)
                {
                    if (setAlarmFlag)
                    {
                        switch (setIndex)
                        {
                            case 1:
                                rateAlarm++;
                                if (rateAlarm > 200)
                                {
                                    rateAlarm = 200;
                                }
                                break;
                            case 2:
                                totalDist = 0;
                                break;
                        }
                        DispAlarm(setIndex, setAlarmFlag);
                    }
                }
                else
                {
                    if (pwmValue <= 11)
                    {
                        pwmValue++;
                    }
                }
            }
            //while (!KEY_UP);
        }

        if (!KEY_DOWN) //下键按下
        {
            DelayMs(150);
            if (!KEY_DOWN)
            {
                if (dispMode == DISP_TIME_MODE)
                {
                    if (setTimeFlag == 1)
                    {
                        switch (setIndex)
                        {
                        case 1:
                        {
                            if (timeBufDec[1] == 0)
                            {
                                timeBufDec[1] = 100;
                            }
                            timeBufDec[1]--;
                            break;
                        }
                        case 2:
                        {
                            timeBufDec[2]--;
                            if (timeBufDec[2] < 1)
                            {
                                timeBufDec[2] = 12;
                            }
                            break;
                        }
                        case 3:
                        {
                            timeBufDec[3]--;
                            if (timeBufDec[3] < 1)
                            {
                                timeBufDec[3] = YDay(timeBufDec[1], timeBufDec[2]);
                            }
                            break;
                        }
                        case 4:
                        {
                            timeBufDec[7]--;
                            if (timeBufDec[7] < 1)
                            {
                                timeBufDec[7] = 7;
                            }
                            break;
                        }
                        case 5:
                        {
                            if (timeBufDec[4] == 0)
                            {
                                timeBufDec[4] = 24;
                            }
                            timeBufDec[4]--;
                            break;
                        }
                        case 6:
                        {
                            if (timeBufDec[5] == 0)
                            {
                                timeBufDec[5] = 60;
                            }
                            timeBufDec[5]--;
                            break;
                        }
                        case 7:
                        {

                            if (timeBufDec[6] == 0)
                            {
                                timeBufDec[6] = 60;
                            }
                            timeBufDec[6]--;
                            break;
                        }
                        default:;
                        }
                        DispTime(setIndex, setTimeFlag);
                    }
                }
                else if (dispMode == SET_ALARM_MODE)
                {
                    if (setAlarmFlag)
                    {
                        switch (setIndex)
                        {
                            case 1:
                                if (rateAlarm > 0)
                                {
                                    rateAlarm--;
                                }
                                break;
                            case 2:
                                totalDist = 0;
                                break;
                        }
                        DispAlarm(setIndex, setAlarmFlag);
                    }
                }
                else
                {
                    if (pwmValue > 3)
                    {
                        pwmValue--;
                    }
                }
            }
            //while (!KEY_DOWN);
        }

        if (!KEY_LEFT) //左键按下
        {
            DelayMs(10);
            if (!KEY_LEFT)
            {
                if (dispMode == DISP_TIME_MODE)
                {
                    if (setTimeFlag == 1)
                    {
                        setIndex--;
                        if (setIndex < 1)
                        {
                            setIndex = 7;
                        }
                        DispTime(setIndex, setTimeFlag);
                    }
                }
                else if (dispMode == SET_ALARM_MODE)
                {
                    if (setAlarmFlag)
                    {
                        setIndex--;
                        if (setIndex < 1)
                        {
                            setIndex = 2;
                        }
                        DispAlarm(setIndex, setAlarmFlag);
                    }
                }
                
            }
            while (!KEY_LEFT)
                ;
        }

        if (!KEY_RIGHT) //右键按下
        {
            DelayMs(10);
            if (!KEY_RIGHT)
            {
                if (dispMode == DISP_TIME_MODE)
                {
                    if (setTimeFlag == 1)
                    {
                        setIndex++;
                        if (setIndex > 7)
                        {
                            setIndex = 1;
                        }
                        DispTime(setIndex, setTimeFlag);
                    }
                }
                if (setAlarmFlag)
                    {
                        setIndex++;
                        if (setIndex > 2)
                        {
                            setIndex = 1;
                        }
                        DispAlarm(setIndex, setAlarmFlag);
                    }
            }
            while (!KEY_RIGHT)
                ;
        }

        if (!KEY_ENTER) //确认键按下
        {
            DelayMs(10);
            if (!KEY_ENTER)
            {
                if (dispMode == DISP_RATE_MODE)
                {
                    dispMode = DISP_TIME_MODE;
                    setTimeFlag = 0;
                    setIndex = 0;
                }
                else if (dispMode == DISP_TIME_MODE)
                {
                    if (setTimeFlag == 1)
                    {
                        setTimeFlag = 0;
                        setIndex = 0;
                        DS1302_WriteTime();
                        DispTime(setIndex, setTimeFlag);
                    }
                    else
                    {
                        dispMode = SET_ALARM_MODE;
                        setIndex = 0;
                    }
                }
                else if (dispMode == SET_ALARM_MODE)
                {
                    if (setAlarmFlag == 1)
                    {
                        setAlarmFlag = 0;
                        setIndex = 0;
                        WriteEEPROM();
                        DispAlarm(setIndex, setAlarmFlag);
                    }
                    else
                    {
                        dispMode = DISP_RATE_MODE;
                        setIndex = 0;
                    }
                }
            }
            while (!KEY_ENTER)
                ;
        }
}

void EXT1_Init()
{
    IT1 = 1; //下降沿触发
    EX1 = 1; //使能外部中断0
    EA = 1; //打开总中断
}

void EXT1_Interrupt() interrupt 2 using 1
{
    pulseCnt++;
}

void Timer0_Init(void)
{
    TMOD &= 0xF0; //定时器模式0
    TMOD |= 0x01;
    PT0 = 1; //设置T0为高优先级
    TH0 = RH_10MS(3); //10ms
    TL0 = RL_10MS(3);
    TR0 = 1; //启动T0计时
    ET0 = 1; //打开T0中断
    EA = 1;  //打开总中断
}

void Timer0_Intterupt(void) interrupt 1 using 0
{
    static unsigned int cnt=0;   
    static unsigned char IN1Count = 0;
    
//    TH0 = 0xF8; //设置定时初值
//    TL0 = 0xCD; //设置定时初值 2ms
    
    TH0 = 0xFC; //设置定时初值
    TL0 = 0x66; //设置定时初值 1ms
    
    IN1Count++;
    cnt++;
    
    if (motorFlag == 1)
    {
        if (IN1Count < pwmValue) //占空比调节
        {
            MOTOR = 0;    
        }
        else if ((IN1Count >= pwmValue) && (IN1Count <= 11)) //关闭时间段
        {
            MOTOR = 1;
        }
        else
        {
            IN1Count = 0; //一个周期结束
        }
    }
    else
    {
        MOTOR = 1;
    }
    if (cnt >= 250) //500ms
    {
        dispFlag = ~dispFlag;
        cnt = 0;
    }
}

void Timer1_Init(void)
{
    TMOD &= 0x0F; //定时器模式1
    TMOD |= 0x10;
    TH1 = RH_10MS(5); //50ms
    TL1 = RL_10MS(5);
    TR1 = 1; //开启T1计时
    ET1 = 1; //打开T1中断
    EA = 1;  //打开总中断
}


void Timer1_Intterupt(void) interrupt 3 using 2
{
    static unsigned int cnt=0;

    TH1 = RH_10MS(5); //50ms
    TL1 = RL_10MS(5);

    cnt++;
    if (cnt >= 20) //1s
    {
        EX1 = 0;
        if (second >= 60)
        {
            second = 0;
            minute++;
            if (minute == 1)
            {
                writeFlag = 1;
                minute = 0;
            }
        }
        else
        {
            second++;
        }
        
        refreshFlag = 1;
        cnt = 0;
    }
}

仿真演示视频：
https://www.bilibili.com/video/BV13R4y1G7k4/

实物演示视频：
https://www.bilibili.com/video/BV1iY411G7AJ/

极寒钛科技
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
PROTEUS仿真之直流电机的使用（速度方向控制）
m0_75241514的博客
05-15 2989
直流电机在proteus中的一些使用方法和技巧
基于51单片机的霍尔自行车里程测速仪（含Keil程序和Proteus文件）
XCHardware的博客
08-19 1563
1.通过LCD1602显示实时车速。2.通过霍尔测速模块进行速度检测。3.通过在霍尔模块处模拟开关量的变化，变化速度越快则显示的车速越快。
单片机电动自行车设计（keil完整源项目+源c代码+proteus源仿真电路图）
08-08
单片机电动自行车设计（keil完整源项目+源c代码+proteus源仿真电路图）
基于51单片机的电动车防盗系统proteus仿真
weixin_44116175的博客
06-29 1346
硬件设计 （末尾附文件） 代码设计 #include <reg52.h> #define uc unsigned char #define ui unsigned int sbit SOS = P1^2;//测试 sbit bufang = P1^4;//布放按键 sbit chefang= P1^3;//撤防 sbit baojing= P1^1;//蜂鸣器 sbit jdq = P1^0;//继电器 sbit led1=P0^2; sbit led2=P0^3; sbit sos1=P
51单片机自行车码表 速度里程计霍尔测速模拟电机设计
bbxyliyang的博客
09-25 702
最后根据测试没问题的仿真图纸，焊接实物，调试，最终完成本设计的作品。本设计采用51单片机作为主控器，霍尔测速，数码管显示速度及里程数。//将100ms内的脉冲数。//里程m=速度km/h。TMOD=0x01;//定时器工作于方式1。//INT0负跳变触发。//CPU开中断总允许。//开外部INTO中断。四、 proteus仿真设计。1、首先是系统初始化。
【单片机毕业设计】【mcuclub-cl-020】基于单片机的电动车防盗的设计
weixin_61121477的博客
10-27 1046
电动车防盗
基于单片机的车速控制语音报警系统
毕业作品网站
10-15 1210
该系统进行5V供电，通过USB端口可直接供电，模块接通电源后，霍尔测速模块通过检测电机转速（通过电机扇轮上的强磁）实现速度的测量和报警的提示，数码管显示电机当前转速，语音模块进行超速报警，当速度超过每分钟300转的时候语音模块进行报警提示，速度的检测为三秒钟检测一次，并用数码管实时显示，语音模块根据显示结果进行选择性报警，此时一次工作周期完成。id=13754电机的两个接口（可不分正反），按照顺序接线，通电后即可正常使用。1：单只数码管 * 4；11：铜柱，螺丝若干；1，杜邦线若干，电源线。
基于51单片机的速度测量报警（数码管，上下限）proteus，原理图、流程图、物料清单、仿真图、源代码
最新发布
01-16
基于51单片机的速度测量报警（数码管，上下限）proteus，原理图、流程图、物料清单、仿真图、源代码 基于51单片机的速度测量报警（数码管，上下限） 速度检测报警器（车速报警、风速报警等） 1、测量转速脉冲频率，...
基于51单片机的智能交通灯车速、车距检测（速度，距离）proteus、原理图、流程图、物料清单、仿真图、源代码
01-13
基于51单片机的智能交通灯车速、车距检测（速度，距离）proteus、原理图、流程图、物料清单、仿真图、源代码 基于51单片机的交通灯（速度，距离） 东西、南北两干道交于十字路口，各干道均有一组红、绿、黄指示灯，...
基于51单片机的智能车辆倒车停车控制系统（速度，距离）proteus，原理图、流程图、物料清单、仿真图、源代码
01-13
基于51单片机的智能车辆倒车停车控制系统（速度，距离）proteus，原理图、流程图、物料清单、仿真图、源代码 基于51单片机的车辆停车（速度，距离） 车辆停车过程监控，保证停车安全 1、使用超声波模块检测周围车辆...
基于AVR单片机出租车计价器Proteus仿真及程序
08-08
在本项目中，我们关注的是基于AVR单片机的出租车计价器的实现，它主要涉及嵌入式系统设计、微控制器编程以及电路仿真。AVR单片机是由Atmel公司（现已被Microchip Technology收购）开发的一种高效、低功耗的8位微处理...
基于51单片机简易霍尔自行车里程测速仪设计资料（包含源程序、原理图、参考论文及相关制作文件）
08-29
基于51单片机简易霍尔自行车里程测速仪设计资料（包含源程序、原理图、参考论文及相关制作文件）
Proteus单片机 自行车测速仿真（仿真实例）.rar
04-15
免责声明：资料部分来源于合法的互联网渠道收集和整理，部分自己学习积累成果，供大家学习参考与交流。收取的费用仅用于收集和整理资料耗费时间的酬劳。 本人尊重原创作者或出版方，资料版权归原作者或出版方所有，本人不对所涉及的版权问题或内容负法律责任。如有侵权，请举报或通知本人删除。
Proteus仿真自行车测速仿真+代码+DSN
06-20
基于89C51单片机/89C52单片机通用的自行车测速仿真，Proteus软件测试运行环境7.8版本，包含内容：keil vision5项目文件、C语言程序源码、hex后缀编译文件、DSN仿真后缀文件项目.
霍尔传感器 自行车测速、里程报警显示系统
03-08
霍尔传感器 自行车测速、里程报警显示系统
Proteus合集（电路图、仿真程序）仅供参考.zip
03-05
proteus仿真合集：串口通信、流水灯、开发板、电机控制正反转、ADC数模转换模块、定时计数器、滚动汉字显示、时钟电路等等，各种课程设计经典案例。仅供设计参考，不作他用。
51 Proteus仿真自行车速度里程计时间显示脉冲测速-0021
zhaxiaobian_er的博客
02-27 1095
硬件组成：51单片机 +LCD1602显示器+DS1302时钟模块+1个清零键+蜂鸣器报警+信号发生器（模拟速度） 1.准确测量信号发生器的脉冲频率换算为车轮转速，车速(千米/小时)=车轮转速*车轮周长， 脉冲频率和车速显示在LCD1602上面。 2.获取DS1302的北京时间，根据时间结合车速计算出里程显示在LCD1602上面。 3.具有超速报警，当车速30千米/秒时蜂鸣器报警。提示驾驶人超速了。
基于单片机的电动车防盗报警系统设计proteus仿真
09-06
基于单片机的电动车防盗报警系统设计可以通过Proteus仿真软件进行模拟。首先，需要设计一个电路，包括单片机、传感器和警报器等组件。 在Proteus中，可以选择合适的单片机模型并进行初始化设置。接下来，需要将传感器与单片机进行连接，例如将门锁传感器与单片机的GPIO引脚相连，以检测车门是否被打开。 然后，可以设置一个定时器，在一定的时间间隔内检测传感器的状态。当传感器检测到车门被打开时，单片机会接收到相应的信号，并触发一定的报警逻辑。 在Proteus中，可以使用LED模型作为警报器，并将其与单片机的某个输出引脚相连。当车门被打开时，单片机会向相应的输出引脚发送高电平信号，使LED点亮，表示触发了防盗报警系统。 通过Proteus可以模拟这个电动车防盗报警系统的运行情况。可以通过设置单片机的输入引脚输入高电平模拟传感器检测到门锁被打开的信号，然后观察警报器是否正确地触发。 通过Proteus仿真，可以帮助开发人员在实际制作硬件之前对系统进行验证和调试。通过模拟各种情况，可以进一步完善防盗报警系统的设计，提高其可靠性和稳定性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值