毕设基于STM32F103ZET6的出租车计价器心得

最新推荐文章于 2024-03-01 16:20:46 发布

jeafer12138

最新推荐文章于 2024-03-01 16:20:46 发布

阅读量1.1k

点赞数 2

文章标签：单片机 stm32 Powered by 金山文档

本文链接：https://blog.csdn.net/jeafer12138/article/details/128735235

版权

- 设计前准备

1、材料清单

使用嘉立创PCB来绘图

优点：新手上手更快、拥有丰富的分装库、操作简单、可直接下单、每月可免费打样两次（10*10cm）

主控PCB用的模块所以都用的排母作为引脚的引出

电机PCB

3、环境配置

使用KEIL5进行程序编写

ST_Link设置

- 模块程序编写

1、syn6288.c

使用淘宝卖家提供的SYN6288程序驱动，只需在SYN_FrameInfo函数中修改值就可以进行简单的使用

#include "syn6288.h"
#include "usart.h"
#include "string.h"
#include "delay.h"


//Music:选择背景音乐。0:无背景音乐，1~15：选择背景音乐
void SYN_FrameInfo(u8 Music, u8 *HZdata)
{
  /****************需要发送的文本**********************************/
  unsigned  char  Frame_Info[50];
  unsigned  char  HZ_Length;
  unsigned  char  ecc  = 0;              //定义校验字节
  unsigned  int i = 0;
  HZ_Length = strlen((char*)HZdata);             //需要发送文本的长度

  /*****************帧固定配置信息**************************************/
  Frame_Info[0] = 0xFD ;             //构造帧头FD
  Frame_Info[1] = 0x00 ;             //构造数据区长度的高字节
  Frame_Info[2] = HZ_Length + 3;         //构造数据区长度的低字节
  Frame_Info[3] = 0x01 ;             //构造命令字：合成播放命令
  Frame_Info[4] = 0x01 | Music << 4 ; //构造命令参数：背景音乐设定

  /*******************校验码计算***************************************/
  for(i = 0; i < 5; i++)                   //依次发送构造好的5个帧头字节
  {
    ecc = ecc ^ (Frame_Info[i]);        //对发送的字节进行异或校验
  }

  for(i = 0; i < HZ_Length; i++)           //依次发送待合成的文本数据
  {
    ecc = ecc ^ (HZdata[i]);                 //对发送的字节进行异或校验
  }
  /*******************发送帧信息***************************************/
  memcpy(&Frame_Info[5], HZdata, HZ_Length);
  Frame_Info[5 + HZ_Length] = ecc;
  USART3_SendString(Frame_Info, 5 + HZ_Length + 1);
}


/***********************************************************
* 名    称： YS_SYN_Set(u8 *Info_data)
* 功    能： 主函数    程序入口
* 入口参数： *Info_data:固定的配置信息变量
* 出口参数：
* 说    明：本函数用于配置，停止合成、暂停合成等设置 ，默认波特率9600bps。
* 调用方法：通过调用已经定义的相关数组进行配置。
**********************************************************/
void YS_SYN_Set(u8 *Info_data)
{
  u8 Com_Len;
  Com_Len = strlen((char*)Info_data);
  USART3_SendString(Info_data, Com_Len);
}

2、霍尔传感器驱动

霍尔传感器的测速使用DO端口进行计数，在DO模式下当磁铁靠近会产生低电平型号，使用中断进行触发并使用一个变量进行计数

#include "stm32f10x.h"
#include "tim_cesu.h"
#include "delay.h"
#include "tim_cesu.h"
#include "delay.h"
u8 quan=0;

void CESU_Init(void)
{   GPIO_InitTypeDef gpio;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA+RCC_APB2Periph_AFIO,ENABLE);//使能GPIOA
    gpio.GPIO_Mode=GPIO_Mode_IPD;
    gpio.GPIO_Pin=GPIO_Pin_7;
    gpio.GPIO_Speed=GPIO_Speed_10MHz;
    GPIO_Init(GPIOA,&gpio);
    
    EXTI_InitTypeDef EXTI_InitStructure;        //中断方式初始化 
       
    GPIO_EXTILineConfig(GPIO_PortSourceGPIOA,GPIO_PinSource7);
    EXTI_ClearITPendingBit(EXTI_Line7);
    EXTI_InitStructure.EXTI_Line=EXTI_Line7;              //指定中断线3
    EXTI_InitStructure.EXTI_LineCmd=ENABLE;                   //使能中断线
    EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt;     //中断模式
    EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Falling; 
    EXTI_Init(&EXTI_InitStructure);
    

}

void NVICinit(void)
{
    NVIC_InitTypeDef nvic;//中断优先级初始化结构体
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); 
    
    nvic.NVIC_IRQChannel =EXTI9_5_IRQn;    ;//使能按键外部中断通道
      nvic.NVIC_IRQChannelPreemptionPriority =2;    //抢占优先级主优先级0
      nvic.NVIC_IRQChannelSubPriority =0x01;//子优先级0-15
      nvic.NVIC_IRQChannelCmd = ENABLE;
      NVIC_Init(&nvic);//初始化中断优先级
     


}
void EXTI9_5_IRQHandler(void)
{    
     if(EXTI_GetFlagStatus(EXTI_Line7)!=RESET)
     {   
         quan=quan+1;
         delay_us(100);
         
       //清空中断标志位，防止持续进入中断
      }
      EXTI_ClearITPendingBit(EXTI_Line7);

}

3、OLED驱动

使用的是正点原子opendv论坛上提供的0.96OLED驱动，使用I2C进行数据的传输。是使用取模软件进行对汉字的取模

#include "oled.h"
#include "stdlib.h"
#include "oledfont.h"       
#include "delay.h"

u8 OLED_GRAM[144][8];

//反显函数
void OLED_ColorTurn(u8 i)
{
    if(i==0)
        {
            OLED_WR_Byte(0xA6,OLED_CMD);//正常显示
        }
    if(i==1)
        {
            OLED_WR_Byte(0xA7,OLED_CMD);//反色显示
        }
}

//屏幕旋转180度
void OLED_DisplayTurn(u8 i)
{
    if(i==0)
        {
            OLED_WR_Byte(0xC8,OLED_CMD);//正常显示
            OLED_WR_Byte(0xA1,OLED_CMD);
        }
    if(i==1)
        {
            OLED_WR_Byte(0xC0,OLED_CMD);//反转显示
            OLED_WR_Byte(0xA0,OLED_CMD);
        }
}

//延时
void IIC_delay(void)
{
    u8 t=3;
    while(t--);
}

//起始信号
void I2C_Start(void)
{
    OLED_SDA_Set();
    OLED_SCL_Set();
    IIC_delay();
    OLED_SDA_Clr();
    IIC_delay();
    OLED_SCL_Clr();
    IIC_delay();
}

//结束信号
void I2C_Stop(void)
{
    OLED_SDA_Clr();
    OLED_SCL_Set();
    IIC_delay();
    OLED_SDA_Set();
}

//等待信号响应
void I2C_WaitAck(void) //测数据信号的电平
{
    OLED_SDA_Set();
    IIC_delay();
    OLED_SCL_Set();
    IIC_delay();
    OLED_SCL_Clr();
    IIC_delay();
}

//写入一个字节
void Send_Byte(u8 dat)
{
    u8 i;
    for(i=0;i<8;i++)
    {
        if(dat&0x80)//将dat的8位从最高位依次写入
        {
            OLED_SDA_Set();
    }
        else
        {
            OLED_SDA_Clr();
    }
        IIC_delay();
        OLED_SCL_Set();
        IIC_delay();
        OLED_SCL_Clr();//将时钟信号设置为低电平
        dat<<=1;
  }
}

//发送一个字节
//mode:数据/命令标志 0,表示命令;1,表示数据;
void OLED_WR_Byte(u8 dat,u8 mode)
{
    I2C_Start();
    Send_Byte(0x78);
    I2C_WaitAck();
    if(mode){Send_Byte(0x40);}
  else{Send_Byte(0x00);}
    I2C_WaitAck();
    Send_Byte(dat);
    I2C_WaitAck();
    I2C_Stop();
}

//开启OLED显示 
void OLED_DisPlay_On(void)
{
    OLED_WR_Byte(0x8D,OLED_CMD);//电荷泵使能
    OLED_WR_Byte(0x14,OLED_CMD);//开启电荷泵
    OLED_WR_Byte(0xAF,OLED_CMD);//点亮屏幕
}

//关闭OLED显示 
void OLED_DisPlay_Off(void)
{
    OLED_WR_Byte(0x8D,OLED_CMD);//电荷泵使能
    OLED_WR_Byte(0x10,OLED_CMD);//关闭电荷泵
    OLED_WR_Byte(0xAE,OLED_CMD);//关闭屏幕
}

//更新显存到OLED    
void OLED_Refresh(void)
{
    u8 i,n;
    for(i=0;i<8;i++)
    {
        OLED_WR_Byte(0xb0+i,OLED_CMD); //设置行起始地址
        OLED_WR_Byte(0x00,OLED_CMD);   //设置低列起始地址
        OLED_WR_Byte(0x10,OLED_CMD);   //设置高列起始地址
        I2C_Start();
        Send_Byte(0x78);
        I2C_WaitAck();
        Send_Byte(0x40);
        I2C_WaitAck();
        for(n=0;n<128;n++)
        {
            Send_Byte(OLED_GRAM[n][i]);
            I2C_WaitAck();
        }
        I2C_Stop();
  }
}
//清屏函数
void OLED_Clear(void)
{
    u8 i,n;
    for(i=0;i<8;i++)
    {
       for(n=0;n<128;n++)
            {
             OLED_GRAM[n][i]=0;//清除所有数据
            }
  }
    OLED_Refresh();//更新显示
}

//画点 
//x:0~127
//y:0~63
//t:1 填充 0,清空    
void OLED_DrawPoint(u8 x,u8 y,u8 t)
{
    u8 i,m,n;
    i=y/8;
    m=y%8;
    n=1<<m;
    if(t){OLED_GRAM[x][i]|=n;}
    else
    {
        OLED_GRAM[x][i]=~OLED_GRAM[x][i];
        OLED_GRAM[x][i]|=n;
        OLED_GRAM[x][i]=~OLED_GRAM[x][i];
    }
}

//画线
//x1,y1:起点坐标
//x2,y2:结束坐标
void OLED_DrawLine(u8 x1,u8 y1,u8 x2,u8 y2,u8 mode)
{
    u16 t; 
    int xerr=0,yerr=0,delta_x,delta_y,distance;
    int incx,incy,uRow,uCol;
    delta_x=x2-x1; //计算坐标增量 
    delta_y=y2-y1;
    uRow=x1;//画线起点坐标
    uCol=y1;
    if(delta_x>0)incx=1; //设置单步方向 
    else if (delta_x==0)incx=0;//垂直线 
    else {incx=-1;delta_x=-delta_x;}
    if(delta_y>0)incy=1;
    else if (delta_y==0)incy=0;//水平线 
    else {incy=-1;delta_y=-delta_x;}
    if(delta_x>delta_y)distance=delta_x; //选取基本增量坐标轴 
    else distance=delta_y;
    for(t=0;t<distance+1;t++)
    {
        OLED_DrawPoint(uRow,uCol,mode);//画点
        xerr+=delta_x;
        yerr+=delta_y;
        if(xerr>distance)
        {
            xerr-=distance;
            uRow+=incx;
        }
        if(yerr>distance)
        {
            yerr-=distance;
            uCol+=incy;
        }
    }
}
//x,y:圆心坐标
//r:圆的半径
void OLED_DrawCircle(u8 x,u8 y,u8 r)
{
    int a, b,num;
    a = 0;
    b = r;
    while(2 * b * b >= r * r)      
    {
        OLED_DrawPoint(x + a, y - b,1);
        OLED_DrawPoint(x - a, y - b,1);
        OLED_DrawPoint(x - a, y + b,1);
        OLED_DrawPoint(x + a, y + b,1);
 
        OLED_DrawPoint(x + b, y + a,1);
        OLED_DrawPoint(x + b, y - a,1);
        OLED_DrawPoint(x - b, y - a,1);
        OLED_DrawPoint(x - b, y + a,1);
        
        a++;
        num = (a * a + b * b) - r*r;//计算画的点离圆心的距离
        if(num > 0)
        {
            b--;
            a--;
        }
    }
}



//在指定位置显示一个字符,包括部分字符
//x:0~127
//y:0~63
//size1:选择字体 6x8/6x12/8x16/12x24
//mode:0,反色显示;1,正常显示
void OLED_ShowChar(u8 x,u8 y,u8 chr,u8 size1,u8 mode)
{
    u8 i,m,temp,size2,chr1;
    u8 x0=x,y0=y;
    if(size1==8)size2=6;
    else size2=(size1/8+((size1%8)?1:0))*(size1/2);  //得到字体一个字符对应点阵集所占的字节数
    chr1=chr-' ';  //计算偏移后的值
    for(i=0;i<size2;i++)
    {
        if(size1==8)
              {temp=asc2_0806[chr1][i];} //调用0806字体
        else if(size1==12)
        {temp=asc2_1206[chr1][i];} //调用1206字体
        else if(size1==16)
        {temp=asc2_1608[chr1][i];} //调用1608字体
        else if(size1==24)
        {temp=asc2_2412[chr1][i];} //调用2412字体
        else return;
        for(m=0;m<8;m++)
        {
            if(temp&0x01)OLED_DrawPoint(x,y,mode);
            else OLED_DrawPoint(x,y,!mode);
            temp>>=1;
            y++;
        }
        x++;
        if((size1!=8)&&((x-x0)==size1/2))
        {x=x0;y0=y0+8;}
        y=y0;
  }
}


//显示字符串
//x,y:起点坐标  
//size1:字体大小 
//*chr:字符串起始地址 
//mode:0,反色显示;1,正常显示
void OLED_ShowString(u8 x,u8 y,u8 *chr,u8 size1,u8 mode)
{
    while((*chr>=' ')&&(*chr<='~'))//判断是不是非法字符!
    {
        OLED_ShowChar(x,y,*chr,size1,mode);
        if(size1==8)x+=6;
        else x+=size1/2;
        chr++;
  }
}

//m^n
u32 OLED_Pow(u8 m,u8 n)
{
    u32 result=1;
    while(n--)
    {
      result*=m;
    }
    return result;
}

//显示数字
//x,y :起点坐标
//num :要显示的数字
//len :数字的位数
//size:字体大小
//mode:0,反色显示;1,正常显示
void OLED_ShowNum(u8 x,u8 y,u32 num,u8 len,u8 size1,u8 mode)
{
    u8 t,temp,m=0;
    if(size1==8)m=2;
    for(t=0;t<len;t++)
    {
        temp=(num/OLED_Pow(10,len-t-1))%10;
            if(temp==0)
            {
                OLED_ShowChar(x+(size1/2+m)*t,y,'0',size1,mode);
      }
            else 
            {
              OLED_ShowChar(x+(size1/2+m)*t,y,temp+'0',size1,mode);
            }
  }
}

//显示汉字
//x,y:起点坐标
//num:汉字对应的序号
//mode:0,反色显示;1,正常显示
void OLED_ShowChinese(u8 x,u8 y,u8 num,u8 size1,u8 mode)
{
    u8 m,temp;
    u8 x0=x,y0=y;
    u16 i,size3=(size1/8+((size1%8)?1:0))*size1;  //得到字体一个字符对应点阵集所占的字节数
    for(i=0;i<size3;i++)
    {
        if(size1==16)
                {temp=Hzk1[num][i];}//调用16*16字体
        else if(size1==24)
                {temp=Hzk2[num][i];}//调用24*24字体
        else if(size1==32)       
                {temp=Hzk3[num][i];}//调用32*32字体
        else if(size1==64)
                {temp=Hzk4[num][i];}//调用64*64字体
        else return;
        for(m=0;m<8;m++)
        {
            if(temp&0x01)OLED_DrawPoint(x,y,mode);
            else OLED_DrawPoint(x,y,!mode);
            temp>>=1;
            y++;
        }
        x++;
        if((x-x0)==size1)
        {x=x0;y0=y0+8;}
        y=y0;
    }
}

//num 显示汉字的个数
//space 每一遍显示的间隔
//mode:0,反色显示;1,正常显示
void OLED_ScrollDisplay(u8 num,u8 space,u8 mode)
{
    u8 i,n,t=0,m=0,r;
    while(1)
    {
        if(m==0)
        {
        OLED_ShowChinese(128,24,t,16,mode); //写入一个汉字保存在OLED_GRAM[][]数组中
            t++;
        }
        if(t==num)
            {
                for(r=0;r<16*space;r++)      //显示间隔
                 {
                    for(i=1;i<144;i++)
                        {
                            for(n=0;n<8;n++)
                            {
                                OLED_GRAM[i-1][n]=OLED_GRAM[i][n];
                            }
                        }
           OLED_Refresh();
                 }
        t=0;
      }
        m++;
        if(m==16){m=0;}
        for(i=1;i<144;i++)   //实现左移
        {
            for(n=0;n<8;n++)
            {
                OLED_GRAM[i-1][n]=OLED_GRAM[i][n];
            }
        }
        OLED_Refresh();
    }
}

//x,y：起点坐标
//sizex,sizey,图片长宽
//BMP[]：要写入的图片数组
//mode:0,反色显示;1,正常显示
void OLED_ShowPicture(u8 x,u8 y,u8 sizex,u8 sizey,u8 BMP[],u8 mode)
{
    u16 j=0;
    u8 i,n,temp,m;
    u8 x0=x,y0=y;
    sizey=sizey/8+((sizey%8)?1:0);
    for(n=0;n<sizey;n++)
    {
         for(i=0;i<sizex;i++)
         {
                temp=BMP[j];
                j++;
                for(m=0;m<8;m++)
                {
                    if(temp&0x01)OLED_DrawPoint(x,y,mode);
                    else OLED_DrawPoint(x,y,!mode);
                    temp>>=1;
                    y++;
                }
                x++;
                if((x-x0)==sizex)
                {
                    x=x0;
                    y0=y0+8;
                }
                y=y0;
     }
     }
}
//OLED的初始化
void OLED_Init(void)
{
    GPIO_InitTypeDef  GPIO_InitStructure;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD, ENABLE);     //使能A端口时钟
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;     
     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;          
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//速度50MHz
     GPIO_Init(GPIOB, &GPIO_InitStructure);      
     GPIO_SetBits(GPIOB,GPIO_Pin_6|GPIO_Pin_7);

    
    OLED_RES_Clr();
    delay_ms(200);
    OLED_RES_Set();
    
    OLED_WR_Byte(0xAE,OLED_CMD);//--turn off oled panel
    OLED_WR_Byte(0x00,OLED_CMD);//---set low column address
    OLED_WR_Byte(0x10,OLED_CMD);//---set high column address
    OLED_WR_Byte(0x40,OLED_CMD);//--set start line address  Set Mapping RAM Display Start Line (0x00~0x3F)
    OLED_WR_Byte(0x81,OLED_CMD);//--set contrast control register
    OLED_WR_Byte(0xCF,OLED_CMD);// Set SEG Output Current Brightness
    OLED_WR_Byte(0xA1,OLED_CMD);//--Set SEG/Column Mapping     0xa0左右反置 0xa1正常
    OLED_WR_Byte(0xC8,OLED_CMD);//Set COM/Row Scan Direction   0xc0上下反置 0xc8正常
    OLED_WR_Byte(0xA6,OLED_CMD);//--set normal display
    OLED_WR_Byte(0xA8,OLED_CMD);//--set multiplex ratio(1 to 64)
    OLED_WR_Byte(0x3f,OLED_CMD);//--1/64 duty
    OLED_WR_Byte(0xD3,OLED_CMD);//-set display offset    Shift Mapping RAM Counter (0x00~0x3F)
    OLED_WR_Byte(0x00,OLED_CMD);//-not offset
    OLED_WR_Byte(0xd5,OLED_CMD);//--set display clock divide ratio/oscillator frequency
    OLED_WR_Byte(0x80,OLED_CMD);//--set divide ratio, Set Clock as 100 Frames/Sec
    OLED_WR_Byte(0xD9,OLED_CMD);//--set pre-charge period
    OLED_WR_Byte(0xF1,OLED_CMD);//Set Pre-Charge as 15 Clocks & Discharge as 1 Clock
    OLED_WR_Byte(0xDA,OLED_CMD);//--set com pins hardware configuration
    OLED_WR_Byte(0x12,OLED_CMD);
    OLED_WR_Byte(0xDB,OLED_CMD);//--set vcomh
    OLED_WR_Byte(0x40,OLED_CMD);//Set VCOM Deselect Level
    OLED_WR_Byte(0x20,OLED_CMD);//-Set Page Addressing Mode (0x00/0x01/0x02)
    OLED_WR_Byte(0x02,OLED_CMD);//
    OLED_WR_Byte(0x8D,OLED_CMD);//--set Charge Pump enable/disable
    OLED_WR_Byte(0x14,OLED_CMD);//--set(0x10) disable
    OLED_WR_Byte(0xA4,OLED_CMD);// Disable Entire Display On (0xa4/0xa5)
    OLED_WR_Byte(0xA6,OLED_CMD);// Disable Inverse Display On (0xa6/a7) 
    OLED_Clear();
    OLED_WR_Byte(0xAF,OLED_CMD);
}

4、按键模块

拉高引脚输出高电平，当按键按下按键接地端会将端口电平拉低，调用内置函数读取应交状态

#include "stm32f10x.h"
#include "key.h"
#include "sys.h" 
#include "delay.h"

                             
//按键初始化函数
void KEY_Init(void) //IO初始化
{ 
    GPIO_InitTypeDef GPIO_InitStructure;

     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC,ENABLE);//使能PORTA,PORTC时钟

    GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);//关闭jtag，使能SWD，可以用SWD模式调试
    
    GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_15;//PA15
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //设置成上拉输入
     GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA15
    
    GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_5;//PC5
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //设置成上拉输入
     GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化GPIOC5
 
    GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_0;//PA0
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //PA0设置成输入，默认下拉      
    GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.0
}
u8 KEY_Scan(u8 mode)
{     
    static u8 key_up=1;//按键按松开标志
    if(mode)key_up=1;  //支持连按          
    if(key_up&&(KEY0==0||KEY1==0||WK_UP==1))
    {
        delay_ms(10);//去抖动 
        key_up=0;
        if(KEY0==0)return KEY0_PRES;
        else if(KEY1==0)return KEY1_PRES;
        else if(WK_UP==1)return WKUP_PRES; 
    }else if(KEY0==1&&KEY1==1&&WK_UP==0)key_up=1;          
    return 0;// 无按键按下
}

5、红外人体感应

HC_SR505当有人靠近并移动时输出高电平，当人离开大概8S后输出低电平，在8S内会一直输出高电平且在期间有检测到移动，会将高电平时间进行顺言。

#include "stm32f10x.h"
#include "red_wire.h"


void red_wire_Init(void)
{   

    GPIO_InitTypeDef gpio;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA+RCC_APB2Periph_AFIO,ENABLE);//使能GPIOA
    gpio.GPIO_Mode=GPIO_Mode_IPD;
    gpio.GPIO_Pin=GPIO_Pin_6;
    gpio.GPIO_Speed=GPIO_Speed_10MHz;
    GPIO_Init(GPIOA,&gpio);
    

}

6、主函数

流程为当有人触发红外，播报价格提醒，结束后KEY1控制启动，KEY2暂停，KEY3结束行程清零所有参数并向乘客播报。其中使用变量使红外在本轮中只能被执行一次，当结束时在对其清零。在测试过程中发现，霍尔传感器在被出发时会计两次数，所以在调用参数时对其进行除2的操作。

#include "sys.h"
#include "delay.h"
#include "stdio.h"
#include "usart.h"
#include "syn6288.h"
#include "oled.h"
#include "bmp.h"
#include "tim_cesu.h"
#include "key.h"
#include "tb6612.h"
#include "led.h"
#include "red_wire.h"
#include "stm32f10x.h"
extern u8 quan;//tim_cesu中记录圈数的zhi


/**************芯片设置命令*********************/
u8 SYN_StopCom[] = {0xFD, 0X00, 0X02, 0X02, 0XFD}; //停止合成
u8 SYN_SuspendCom[] = {0XFD, 0X00, 0X02, 0X03, 0XFC}; //暂停合成
u8 SYN_RecoverCom[] = {0XFD, 0X00, 0X02, 0X04, 0XFB}; //恢复合成
u8 SYN_ChackCom[] = {0XFD, 0X00, 0X02, 0X21, 0XDE}; //状态查询
u8 SYN_PowerDownCom[] = {0XFD, 0X00, 0X02, 0X88, 0X77}; //进入POWER DOWN 状态命令

void run()
{
    TIM_SetCompare2(TIM1,1000);//设置TIMx捕获比较1寄存器值  此处为TIM1通道1 占空比为50%
    PBout(12)=1;
    PBout(13)=0;
    PBout(0)=1;
    PBout(1)=0;
}

void stop()
{
    PBout(12)=0;
    PBout(13)=0;
    PBout(0)=0;
    PBout(1)=0;
}



void shwo_Foat_to_u8(u8 x,u8 y,float a)
{
    u8 qian,hou;
    unsigned char b[7]; 
    
    qian=(u8)a;//提取将整数部分
    b[0]=qian/100+'0';
    b[1]=qian/10%10+'0';
    b[2]=qian%10+'0';
    b[3]='.';
    hou=(a-(u8)a)*100;
    b[4]=hou/10%10+'0';
    b[5]=hou%10+'0';
    OLED_ShowString(x,y,b,16,1);
}



int main(void)
{        
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级
    delay_init();
    USART3_Init(9600);//设置语音播报的波特率
    CESU_Init();
    NVICinit();
    KEY_Init(); 
    LED_Init();    
    TB6612_Ctrl_Init();
    TB6612_Config();
    delay_init();
    OLED_Init();
    red_wire_Init();
    float  mile=0;
    float  money=0;
    char   date[20];
    u8 startvalue=10;
    

    u8 t=0;
    u8 a=0;
    u8 c=0;
    
    OLED_ColorTurn(0);//0正常显示，1 反色显示
    OLED_DisplayTurn(0);//0正常显示 1 屏幕翻转显示
    OLED_ShowChinese(0,0,0,16,1);
    OLED_ShowChinese(16,0,1,16,1);
    OLED_ShowChinese(48,0,4,16,1);//每
    OLED_ShowChinese(64,0,5,16,1);//公
    OLED_ShowChinese(80,0,6,16,1);//理
    OLED_ShowString(96,0,"2.5",16,1);
    
    OLED_ShowChinese(0,48,11,16,1);//里
    OLED_ShowChinese(16,48,12,16,1);//程
    OLED_ShowChinese(32,48,15,16,1);//：

    OLED_ShowChinese(0,16,13,16,1);//价
    OLED_ShowChinese(16,16,14,16,1);//格
    OLED_ShowChinese(32,16,15,16,1);
    

    while(1)
    {
        mile=(quan/2)*0.196;
        money=startvalue+mile*2.5;
        t=KEY_Scan(0);        //得到键值


       
        switch(t)
        {                 
            case KEY0_PRES:    LED0=1;
                           

                               run();
                            
                break;
            case KEY1_PRES:
                            LED1=0;
                            stop();
                break;
            case WKUP_PRES:        
                           
                            LED1=1;                              stop();
                           sprintf(date,"%s%.2f%s%s%.2f%s","本次行程结束共计行驶",mile,"公里","共消费",money,"元");
                           SYN_FrameInfo(6,(uint8_t *)date);
                            delay_ms(9600);
                            quan=0;a=0;c=0;
                break;
            default:
                            delay_ms(10);    
        } 

        shwo_Foat_to_u8(48,48,mile);
        OLED_ShowString(108,48,"KM",16,1);
        shwo_Foat_to_u8(48,16,money);
        OLED_ShowChinese(108,16,7,16,1);
        OLED_Refresh();
            if(a==0)
            {
            
                if(GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_6)==1)
                {  
                    a++;
                    delay_ms(10);

                    if(GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_6)==SET)
                    {
                        LED0=!LED0;
                        SYN_FrameInfo(0,"欢迎乘坐本次出租车本车起步价十元白天2.5元每公里夜晚3.5元每公里");

          
                    }
                }
            }
      }
}