基于51单片机的带方位指示的自行车码表proteus仿真原理图PCB

已于 2023-10-02 14:39:08 修改
阅读量643 收藏 7
点赞数 1
文章标签： 51单片机 proteus 单片机
于 2022-11-03 09:41:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jimo167913/article/details/127663890
版权

功能介绍：
0.本系统采用STC89C52作为单片机
1.采用LCD1602液晶可实时显示码表信息
2.蜂鸣器和LED组成声光报警电路，当速度超过设定的阈值启动报警
3.DS1302时钟芯片可实时显示系统时间
4.采用DC002作为电源接口可直接输入5V给整个系统供电
5.设计的EEPROM支持掉电数据保存，下次使用可查看上次码表记录的相关信息
6.方位传感器采用HMC5883L模块，支持自行车或其他载体的方位信息
7.采用小电机和霍尔传感器模拟车子运动的过程

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

PCB：
在这里插入图片描述

主程序：

#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 = 8;
unsigned char setIndex = 0;
unsigned char xdata dispRow0[16];
unsigned char xdata dispRow1[16];

enum{
    DISP_RATE_MODE, DISP_DIR_MODE, DISP_TIME_MODE, SET_ALARM_MODE
} dispMode;

void main()
{
    MOTOR = 0; 
    MOTOR_N = 0; //电机关闭
    //初始化
    LCD_Init();
    DS1302_Init();
    EEPROM_Init();

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

    ReadEEPROM();
    // isNewFlag = 1;
    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!    ");
    HMC5883_Init();
    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_DIR_MODE) //显示方向
            {
                DispDirection();
            }
            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 DispDirection(void) //显示方向
{
    xdata char dis[16];
    xdata float GaX, GaY;
    xdata unsigned int angle;
    
    HMC5883_MultipleRead();

    GaX = (float)(BUF[0] << 8 | BUF[1]) / 1090; // Combine MSB and LSB of X Data output register
    //GaZ = (BUF[2] << 8 | BUF[3]) / 1090; // Combine MSB and LSB of Z Data output register
    GaY = (float)(BUF[4] << 8 | BUF[5]) / 1090; // Combine MSB and LSB of Y Data output register

    if ((GaX > 0) && (GaY > 0))
        angle = atan(GaY / GaX) * 57;
    else if ((GaX > 0) && (GaY < 0))
        angle = 360 + atan(GaY / GaX) * 57;
    else if ((GaX == 0) && (GaY > 0))
        angle = 90;
    else if ((GaX == 0) && (GaY < 0))
        angle = 270;
    else if (GaX < 0)
        angle = 180 + atan(GaY / GaX) * 57;
        
    angle = angle + 90 - 37; //手动校正
    
    if (angle >= 360)
    {
        angle = angle - 360;
    }
    
    LCD_DispStr(0, 0, "You are heading ");
    
    sprintf(dis, "  A:%03d", angle);
    LCD_DispStr(0, 1, dis);
    LCD_DispOneChar(7, 1, 0xdf);

    if ((angle < 22.5) || (angle > 337.5))
    {
        LCD_DispStr(10, 1, "N  ");
    }
    else if ((angle >= 22.5) && (angle < 67.5))
    {
        LCD_DispStr(10, 1, "N-E");
    }
    else if ((angle >= 67.5) && (angle < 112.5))
    {
        LCD_DispStr(10, 1, "E  ");
    }
    else if ((angle >= 112.5) && (angle < 157.5))
    {
        LCD_DispStr(10, 1, "S-E");
    }
    else if ((angle >= 157.5) && (angle < 202.5))
    {
        LCD_DispStr(10, 1, "S  ");
    }
    else if ((angle >= 202.5) && (angle < 247.5))
    {
        LCD_DispStr(10, 1, "S-W");
    }
    else if ((angle >= 247.5) && (angle < 292.5))
    {
        LCD_DispStr(10, 1, "W  ");
    }
    else if ((angle >= 292.5) && (angle < 337.5))
    {
        LCD_DispStr(10, 1, "N-W");
    }
}

void DispAlarm(unsigned char setIndex, bit setAlarmFlag) //显示报警速度
{


    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() //显示当前速度
{

    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) //显示时间
{

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

    sprintf(dispRow0, "%02d/%02d/%02d   ", (int)timeBufDec[1], (int)timeBufDec[2], (int)timeBufDec[3]);
    sprintf(dispRow1, "    %02d:%02d:%02d    ", (int)timeBufDec[4], (int)timeBufDec[5], (int)timeBufDec[6]);

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

    switch (timeBufDec[7])
    {
        case 0: LCD_DispStr(10, 0, " Sun. "); break;
        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:
                                
                                if (rateAlarm > 200)
                                {
                                    rateAlarm = 200;
                                }
                                else
                                {
                                    rateAlarm++;
                                }
                                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 = 0;
                                }
                                else
                                {
                                    rateAlarm--;
                                }
                                break;
                            case 2:
                                totalDist = 0;
                                break;
                        }
                        DispAlarm(setIndex, setAlarmFlag);
                    }
                }
                else
                {
                    if (pwmValue > 8)
                    {
                        pwmValue--;
                    }
                }
            }
            //while (!KEY_DOWN);
        }

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

极寒钛科技
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于单片机的自行车码表
weixin_30593443的博客
05-22 1128
最近毕业设计中接了别人几个项目，忙完一阵是时候做一些总结。 项目名：基于单片机的自行车码表设计 功能需求： 1可以测量当前的温度和湿度并显示出来。 2时间显示。 3实时速度和行驰里程显示。 4设定里程提醒。 根据功能需求决定硬件：单片机使用STC125A60S2具有足...
基于单片机的自行车里程监测系统的设计（自行车码表）
qq_46104872的博客
04-30 2687
基于单片机的自行车里程监测系统的设计（自行车码表） 主要设计内容： 以单片机为主控元件，通过电机转动模拟自行车车轮转动情况； 能够实时显示骑行速度、里程、当前时间和当前温度； 可以通过按键对部分功能数值进行设置； 当骑行速度超过一定值时，可以报警，提示减速。 本设计涉及到单片机、霍尔传感器、温度传感器、时钟芯片、蜂鸣器、显示器、按键、电机等。 本博客由赢sir原创，将以STC89C52、DS18B20、DS1302、LCD1602等为例对硬件电路和软件进行详细的设计介绍，附带Proteus仿真和Keil
自行车码表设计（基于51单片机）
02-25
基于51单片机的自行车码表设计 内附代码和说明
基于51单片机的自行车测速里程码表设计( proteus仿真+程序+设计报告+原理图+讲解视频）
最新发布
weixin_52733843的博客
04-15 2745
基于51单片机的自行车测速里程码表设计( proteus仿真+程序+设计报告+原理图+讲解视频）仿真图proteus7.8及以上程序编译器：keil 4/keil 5编程语言：C语言设计编号：S0078。
（毕业设计资料）基于单片机自行车码表系统设计
DIY_lOVER的博客
12-16 1051
038【毕设课设】基于单片机自行车码表系统设计，实现的功能是按键切换设定校准时间，LCD上显示的时间、踏频、公里数、速度。速度通过输入不同频率方波来实现速度检测模拟，同时有报警功能。包含的电路有单片机控制电路，时钟电路，按键电路，速度采集电路，蜂鸣器电路，液晶显示电路。 【资源下载】下载地址如下：https://docs.qq.com/doc/DTlRSd01BZXNpRUxl #include<reg52.h> #define uchar unsigned char #defi
51单片机码表c语言编程,用AT89S51单片机制作的多功能自行车速度里程表
weixin_34109927的博客
05-18 1326
三、程序设计程序用C语言编写，由主程序、外部中断0服务程序、定时器110中断服务程序、延时子程序等模块组成。主程序由初始化、车轮直径判定和键盘处理三部分组成。车轮直径判定的依据是接在P1口低四位的跳线，跳线接地时表示低电平，不接时表示高电平。其取值与车轮直径、周长对应关系见附表。外部中断0服务程序由测量、计算、读数等组成。从P3.2口输入的脉冲信号作为外部中断0的中断请求信号，外部中断采用边沿触发...
基于51单片机设计的计算器原理图+源代码+proteus仿真
06-10
在本项目中，我们探讨的是一个基于51单片机设计的计算器的实现，包括了原理图、源代码以及Proteus仿真的全套资源。51单片机是微控制器领域的一个经典型号，广泛应用于各种电子设备的设计中，尤其是教学和入门级项目...
基于51单片机的四路温度采集系统电路原理图PCB及仿真
07-10
《基于51单片机的四路温度采集系统电路原理图PCB及仿真》 在电子工程领域，设计和实现一个基于51单片机的四路温度采集系统是一项常见的任务，尤其对于单片机实训而言，这样的项目有助于加深对微控制器应用的理解。...
基于51单片机的自行车测速Proteus仿真
10-15
基于51单片机的自行车测速Proteus仿真是一种用于模拟和测量自行车速度的程序。这个程序使用51单片机作为其核心，通过Proteus仿真软件来模拟单片机的工作过程和测量自行车速度的过程。LCD1602液晶显示屏用于显示测量...
基于C51单片机设计的心型LED仿真proteus仿真图+源码.rar
11-07
本项目以"基于C51单片机设计的心型LED仿真proteus仿真图+源码"为主题，旨在提供一个学习与实践C51单片机控制LED显示的实例。 首先，我们要理解心型LED显示的基本原理。LED（Light Emitting Diode）是发光二极管，...
基于51单片机的波形发生器的Proteus仿真
09-02
基于51单片机的波形发生器的Proteus仿真、 原理图，使用方法 1. 输出矩形波、梯形波、三角波、锯齿波、正弦波五种波形； 2. 每种波形的周期可更改； 3. 每种波形的幅值可更改； 4. 采用lcd12864中文显示屏显示波形...
基于51单片机的自行车码表设计.pdf
07-12
基于51单片机的自行车码表设计.pdf
51单片机自行车码表液晶显示
01-17
基于51单片机的自行车码表设计，可以显示行驶速度，里程，时间，温度，方向等信息，通过1602液晶进行显示
霍尔传感器protues仿真+程序
03-08
比较好霍尔传感器资料
带霍尔传感器的无刷电机驱动仿真_51无刷电机_三相直流无刷_无刷电机仿真_proteus仿真_无刷直流电机
09-10
使用51单片机对带霍尔的三相无刷直流电机仿真
基于单片机的自行车码表设计
咸鱼弟的博客
11-25 3672
word完整版可点击如下下载>>>>>>>> 基于单片机的自行车码表设计-硬件开发文档类资源-CSDN下载内容包括详细设计文档word版，附带开题报告和相关PPT等文档，供大家参考学习。也可在本博客主页找到更多下载资源、学习资料请访问CSDN下载频道.https://download.csdn.net/download/u013253075/40315187 目 录 摘 要----------------------------------......
嵌入式开发之 STM32自行车码表（图文）
热门推荐
eric6079hn的博客
04-16 1万+
嵌入式开发之 STM32自行车码表（图文） 笔者将从以下几个方面逐步深入地讲解STM32F103C8开发板的使用，并在Windows下编写一个简单的自行车码表程序： 元器件 环境搭建 电路连接 一个简单的LED闪烁程序 自行车码表 嵌入式开发之 STM32自行车码表图文 准备工作之 元器件 准备工作之 电路连接 准备工作之 环境搭建 CubeMX配置 Kei
创意小发明：山寨码表.自行车码表的制作 程序原理图，设计图，源代码
从零开始学单片机的博客
02-15 1248
最近比较懒，因缺乏锻炼,加上之前上了2个月的"长夜班",身体有米其林化的趋势.为了阻止这种不良的发展.决定买个二手自行车在家骑自行车锻炼锻炼. 但是很快发现光骑车没劲,于是出于好奇心里 做个码表装上看看能骑多少快,骑了多少路. 废话不多说，先上实物图： 虽然样子有点丑，但是显示效果还是可以滴 单片机用stc89c52，因为之前买了几片还没用掉,因为它只要3块多钱,因为我只要几个IO加上外部中断,...
51单片机码表c语言编程,如何利用单片机设计一个99码表
weixin_32115669的博客
05-18 1006
单片机设计：基于51单片机的99码表设计软件环境：Proteus8.0 + Keil4要求：1，开关按一下，数码管开始计时。2，按两下，数码管显示静止。3，按三下，数码管数值清零。C语言程序如下：#include#define uint unsigned int#define uchar unsigned charuchar shi，ge，aa，keycount=0，temp;sbit anjia...
基于51单片机设计数字秒表包括proteus仿真图
06-12
数字秒表可以使用51单片机的定时器来实现。在程序中，需要定义一个计数器变量，每当定时器产生中断时，计数器变量加1，最终显示在数码管上即可。 以下是一个简单的秒表程序示例： ```C #include sbit LED = P1^0...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值