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

极寒钛科技 极寒钛科技 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 1.9k累计阅读 1.9k平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄7年
关注
原创 2023-10-02 14:17:04 1.9k 阅读 AI 写同款· GEO 优化 ›
基于 51 单片机的电动车控制器 随着技术的不断发展，基于 51 单片机的电动车控制器可能会被更先进的技术所取代，例如 ARM Cortex-M 系列微控制器。基于 51 单片机的电动车控制器是一种使用 51 单片机控制电动车电机和电池的电子设备。它接收来自油门和刹车的输入，并根据预先定义的算法控制电机的速度和方向。基于 51 单片机的电动车控制器是一种可靠且经济高效的解决方案，用于控制电动车电机和电池。基于 51 单片机的电动车控制器对电动车行业产生了重大影响，使电动车更加高效、可靠和易于使用。 阅读详情

功能：
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/

标签
#单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
Proteus仿真自行车测速仿真+代码+DSN 基于89C51单片机/89C52单片机通用的自行车测速仿真，Proteus软件测试运行环境7.8版本，包含内容：keil vision5项目文件、C语言程序源码、hex后缀编译文件、DSN仿真后缀文件项目. 立即下载

相关推荐

Proteus单片机 自行车测速仿真（仿真实例）.rar

免责声明：资料部分来源于合法的互联网渠道收集和整理，部分自己学习积累成果，供大家学习参考与交流。收取的费用仅用于收集和整理资料耗费时间的酬劳。 本人尊重原创作者或出版方，资料版权归原作者或出版方所有，本人不对所涉及的版权问题或内容负法律责任。如有侵权，请举报或通知本人删除。

51单片机_自行车测速仪&自行车里程计

在实现移动车辆装备运行状态监测的需求下，增加了速度测试功能，利用霍尔传感器对移动车辆装备运行时的实时速度和平均速度进行监测。程序中含有报警模块，当发现超速时，该监测装置会立马实现报警，及时的对用户发出提醒。另外程序还添加了温度模块、时钟模块、显示模块以及LCD1602显示屏，以便对移动车辆装备行驶时的状态信息进行实时的显示与监控。显示屏采用传统意义上的串行通讯，通过使用LCD1602显示屏完成显示功能。通过使用DS1302时钟芯片外配RC电池进行外部供电完成实时时钟的功能。设置报警速度及行驶总路程。

heilong99的博客 1622

基于51单片机简易霍尔自行车里程测速仪设计资料（包含源程序、原理图、参考论文及相关制作文件）

基于51单片机简易霍尔自行车里程测速仪设计资料（包含源程序、原理图、参考论文及相关制作文件）

51单片机自行车码表 速度里程计霍尔测速模拟电机设计

最后根据测试没问题的仿真图纸，焊接实物，调试，最终完成本设计的作品。本设计采用51单片机作为主控器，霍尔测速，数码管显示速度及里程数。//将100ms内的脉冲数。//里程m=速度km/h。TMOD=0x01;//定时器工作于方式1。//INT0负跳变触发。//CPU开中断总允许。//开外部INTO中断。四、 proteus仿真设计。1、首先是系统初始化。

bbxyliyang的博客 1034

三维重建笔记_光束平差法(Bundle Adjustment, BA)

目录 1 光束平差法(Bundle Adjustment, BA) 1.1 SFM (Structure‐from‐Motion) 定义 问题描述 1.2 重投影误差 (Reprojection Error) 目标函数 1.3 使用 Levenberg‐Marquardt Algorithm 进行优化 问题描述 简化目标函数 参考 Gauss‐Newton Method ...

惊鸿一博 2万+

DDS信号发生器设计避坑指南：从AD9834配置到巴特沃斯滤波实战

本文详细解析了基于AD9834芯片的DDS信号发生器设计中的关键技术要点与常见陷阱，涵盖时钟源选择、寄存器配置时序、巴特沃斯滤波器设计等核心内容。针对中高频段信号质量优化，提供了实用的解决方案和代码示例，帮助工程师规避设计误区，提升信号发生器的性能和稳定性。

2y3u4i5o6p的博客 782

51 Proteus仿真自行车速度里程计时间显示脉冲测速-0021

硬件组成：51单片机 +LCD1602显示器+DS1302时钟模块+1个清零键+蜂鸣器报警+信号发生器（模拟速度） 1.准确测量信号发生器的脉冲频率换算为车轮转速，车速(千米/小时)=车轮转速*车轮周长， 脉冲频率和车速显示在LCD1602上面。 2.获取DS1302的北京时间，根据时间结合车速计算出里程显示在LCD1602上面。 3.具有超速报警，当车速30千米/秒时蜂鸣器报警。提示驾驶人超速了。

zhaxiaobian_er的博客 1434

如何利用MATLAB建立Lotka-Volterra模型及其改进模型

今天我们要说的就是利用MATLAB对常微分方程进行数值求解的实例应用-Lotka-Volterra模型及其改进模型。20世纪40年代，Lotka（1925）和Volterra（1926）奠定了种间竞争关系的理论基础，他们提出的种间竞争方程对现代生态学理论的发展有着重大影响。

Nick的博客 2万+

PROTEUS资源导引

本仿真专栏的索引导航

夜间去看海的博客 1182

手把手教你逆向京东搜索接口：H5ST 556位参数生成与V8补环境技巧

本文深入解析了京东搜索接口中关键的H5ST 556位参数生成机制，并提供了详细的逆向实战指南。针对其复杂的反爬虫环境检测，文章重点介绍了通过链式补环境技巧，在Node.js中完整模拟浏览器环境（包括原型链检测和指纹验证）的方法，帮助开发者成功绕过防护并生成有效参数。

weixin_29315091的博客 483

【100%通过率】华为OD机试真题 Java&Go 实现【微服务的集成测试】【2023 Q1 | 100分】

现在有n个容器服务，服务的启动可能有一定的依赖性(有些服务启动没有依赖)，其次服务自身启动加载会消耗些时间。给你一个nxn 的二维矩阵 useTime，其中 useTime=10 表示服务i自身启动加载需要消耗10s，useTimeli[j]=1 表示服务i 启动依赖服务i 启动完成，useTimei[k]=0，表示服务i 启动不依赖服务 k其实 0

MISAYAONE的博客 1万+

基于STC89C52的测速和超速报警系统设计

@[TOC]基于STC89C52的测速和超速报警系统设计 电平触发方式时，中断标志寄存器不锁存中断请求信号。单片机把每个机器周期采样到的外部中断源口线的电平逻辑直接赋值到中断标志寄存器。

weixin_41785199的博客 7130

Qt实现思维导图功能1『核心树』

利用Qt的QGraphicsView框架实现思维导图功能 百度网盘体验地址： 链接：https://pan.baidu.com/s/15x9F48agCDOQbsyH3VwVXA 提取码：8svh 注：UI风格参考博主：前行中的小猪，博文地址：https://blog.youkuaiyun.com/GoForwardToStep/article/details/124692790?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_u

浮生流年的博客 6163

基于51单片机的高速汽车列车汽车速度测量及报警装置proteus仿真原理图PCB

2.红外避障模块1触发，启动测速定时器，红外避障模块2触发，停止定时器，完成测速。1.LCD1602液晶显示测量车速，同时蓝牙串口上报速度测量结果。4.采用DC002作为电源接口可直接输入5V给整个系统供电。0.本系统采用STC89C52作为单片机。超过60km/h，蜂鸣器报警。

1933

2011-2024年间各省数字普惠金融指数数据（覆盖广度、使用深度和数字化程度）

2、指标：数字金融普惠指数、数字金融覆盖广度指数、数字金融使用深度指数、普惠金融数字化程度指数、数字金融使用深度指数下属的支付、保险、货币基金、信用服务、投资、信贷等分类指数。中国各省的数字普惠金融指数数据，从数字金融覆盖广度、数字金融使用深度和普惠金融数字化程度3个维度来构建数字普惠金融指标体系。数字普惠金融指数一共3个维度、33项具体指标。全套指数包含数字金融覆盖广度指数、数字金融使用深度指数和普惠金融数字化程度指数，以及数字金融使用深度指数下属的支付、保险、货币基金、信用服务、投资、信贷等分类指数。

【优快云】 1万+

RK3568平台（USB篇）USB HUB集线器

hub，集线器，连接在host与device之间的一种用于usb接口扩展的usb设备。可以将一个usb上行接口扩展为多个下行接口，使得一个host可以同时与多个device连接。一般来说，一块hub桥接芯片可扩展4个usb接口，而市面上的一拖七hub，其实使用了两块hub桥接芯片，其中一块hub桥接芯片的上行端口连接到另一块hub桥接芯片的下行端口。hub的上行端口面向host，下行端口面向device。在下行端口上，hub提供了设备接入检测和设备移除检测的能力，并给下行端口供电。

weixin_49303682的博客 964

基于单片机汽车超速报警系统设计-开题报告

本设计是基于单片机汽车超速报警系统设计，主要实现以下功能：1、通过霍尔传感器检测紫车速度2、使用直流电机模拟汽车运行，并通过按键调节汽车转速3、可以通过按键设置速度阈值，超速报警并语音提示4、第一次超速：灯亮+文字提示，持续15-20s(根据路况 上路前设计限速范围)；5、第二次超速：蜂鸣器报警及语音文字提示，直至速度降至范围内语音和蜂鸣器停止报警；6、第三次超速：系统自动限速标签：51单片机、LCD1602、霍尔传感器、直流电机、语音播报。题目扩展：客车超载系统。

tenas的博客 869

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目，保存在这里方便以后使用直接下载

基于51单片机自行车码表霍尔测速里程显示超速报警方案原理图设计

硬件电路的设计 (下方附文件) 系统的功能分析及体系结构设计 3.1.1系统功能分析 本设计由STC89C52单片机核心电路+DS1302时钟电路+5V电机调速控制电路+霍尔测速电路+蜂鸣器报警电路+按键电路+LCD1602液晶显示电路+电源电路组成。 1、通过时钟芯片DS1302获取时间。 2、LCD1602可以显示当前的速度，里程，时间。 3、按键功能：从左边第一个起，减键、加键、选择键、设置键。 4、可以通过电位器对电机进行调速。 5、具有超速报警功能，可以设置报警速度，当实际的速度大于当前的速度时就

a_huan258147的博客 9982

IEM模型，地表粗糙度模拟

利用微波反演土壤水分时候，利用IEM模型可以实现对随机地表的模拟

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册，内含HL7和ASTM)

电动车简易报警器

材料 STC89C52RC开发板，振动传感器模块，蜂鸣器模块，433M无线模块。

chaun的博客 248

PROTEUS仿真之直流电机的使用（速度方向控制）

直流电机在proteus中的一些使用方法和技巧

m0_75241514的博客 1万+

基于MSP430自行车电机智能测速系统设计（毕业课设）

基于msp430自行车测速装置系统是实时测试车速并显示当前时间，主要由超低功耗单片机MSP430F5419、霍尔传感器、DS1302、段式液晶等组成。以通用MSP430单片机为处理核心，用传感器将车轮的转数转换为电脉冲，进行处理后送入单片机。通过MSP430的定时/计数器测出总的脉冲数和每转一圈的时间，再经过单片机的计算得出，将其自行车测速结果通过段式液晶显示出来。 基于msp430自行车测速装置指标： (1) 利用霍尔传感器检测车圈转动圈数输出脉冲信号； (2) 利用单片机的捕获功能对霍尔传感器脉冲

DIY_lOVER的博客 1693

（附源码）计算机毕业设计SSM基于大数据的汽车流量监控

通过前面的功能分析可以将大数据的汽车流量监控系统的功能分为管理员和用户两个部分，系统的主要功能包括首页、个人中心、用户管理、路口监控管理、时间监控管理、车速监控管理等内容。车速监控管理，在车速监控管理页面可以对索引、路口名称、途径车辆、车辆类型、拥堵情况、最高车速、平均车速、最低车速、检测时间等内容进行详情、修改或删除等操作，如图5-6所示。车速监控管理，在车速监控管理页面可以对索引、路口名称、途径车辆、车辆类型、拥堵情况、最高车速、平均车速、最低车速、检测时间等内容进行详情等操作，如图5-12所示。

学姐计算机毕设程序 1170

基于单片机的霍尔自行车码表的设计与实现-嵌入式毕业设计

技术：C语言、单片机等摘要：本项目基于单片机设计了一款霍尔自行车码表。该系统实现了骑行过程中即时显示行驶速度、行径里程、显示当前时刻以及超速危险报警等功能。有助于骑行者在骑行过程中较为直观的了解诸多信息，并且保障骑行安全，使骑行过程中充满乐趣，带给骑行者更为安全舒适的驾驶体验，另一方面，如果单独使用码表，也可作为一款时钟来使用。关键词：霍尔元器件 STC89C52 1602LCD。

m0_73485055的博客 323

基于单片机自行车自动防盗报警系统设计

*单片机设计介绍，基于单片机自行车自动防盗报警系统设计。

QQ2193276455的博客 1387

基本定时器（TIM6/TIM7）

基本定时器最简单，就干一件事：到点了触发中断。定时器本质就是计数器，每个时钟脉冲加1，数到ARR就溢出、产生中断、清0重来。三个核心寄存器：PSC（预分频器）：对输入时钟分频CNT（计数器）：从0往上数ARR（自动重装载值）：数到这个值就溢出，CNT清0，产生更新中断公式：  定时周期 = (PSC+1) × (ARR+1) / 定时器时钟  更新事件频率 = 定时器时钟 / ((PSC+1) × (ARR+1)) 例：TIM6时钟84MHz，要定时0.5秒（2

2401_89890233的博客 224
上一篇： 基于51单片机的智能自动感应洗手器水龙头控制proteus仿真原理图程序
下一篇： 基于51单片机的八路抢答器汇编语言Proteus仿真原理图程序
点赞 2
评论 0
书签 书签 6
极寒钛科技
极寒钛科技
博客等级 码龄7年 840粉丝 161原创
+ 关注
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值