按键控发送指令并制数码管

资源下载：

STM32_Project_key-uart.zip

bsp_key.h

#ifndef __BSP_KEY_H
#define __BSP_KEY_H
#include "stm32f10x.h"
#define KEY_WAIT_INPUT            0
#define KEY_CONFIRM_INPUT        1
#define KEY_RE_CONFIRM_INPUT    2
#define KEY_RELEASE                3
// 宏定义按键1
#define KEY1_GPIO_PIN                           GPIO_Pin_0
#define KEY1_GPIO_PORT                          GPIOA
#define KEY1_GPIO_CLK                           RCC_APB2Periph_GPIOA
// 宏定义按键2
#define KEY2_GPIO_PIN                           GPIO_Pin_1
#define KEY2_GPIO_PORT                          GPIOA
#define KEY2_GPIO_CLK                           RCC_APB2Periph_GPIOA
// 宏定义按键3
#define KEY3_GPIO_PIN                           GPIO_Pin_2
#define KEY3_GPIO_PORT                          GPIOA
#define KEY3_GPIO_CLK                           RCC_APB2Periph_GPIOA
// 宏定义按键4
#define KEY4_GPIO_PIN                           GPIO_Pin_3
#define KEY4_GPIO_PORT                          GPIOA
#define KEY4_GPIO_CLK                           RCC_APB2Periph_GPIOA
// 宏定义按键5
#define KEY5_GPIO_PIN                           GPIO_Pin_4
#define KEY5_GPIO_PORT                          GPIOA
#define KEY5_GPIO_CLK                           RCC_APB2Periph_GPIOA
#define KEY_ON      1
#define KEY_OFF     0
void KEY_GPIO_Config(void);
uint8_t Key_Scan(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin);
uint8_t Key_Scan_DownUp(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin);
#endif // __BSP_KEY_H

bsp_key.c

#include "bsp_key.h"
// 按钮配置
void KEY_GPIO_Config(void)
{
    GPIO_InitTypeDef  GPIO_InitStruct;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
        // 配置5个按键的引脚
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPU; // 下拉输入
    GPIO_Init(GPIOA, &GPIO_InitStruct);
}
extern uint8_t sw1_flag;
/**
  * @brief  检测SW1按键
  * @param   
  *     
  * @retval 
  */
void Scan_sw1(void)
{
    static uint16_t key_time=0;
    static uint8_t key_state=0;
    static uint8_t signal=0;
    uint8_t key_data; 
    GPIO_SetBits(GPIOA, GPIO_Pin_0);
    key_data = GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0);
    switch(key_state)
    {
        case KEY_WAIT_INPUT://wait key input
            if(key_data == 0)
                key_state = KEY_CONFIRM_INPUT;
            break;
        case KEY_CONFIRM_INPUT://confirm key input
            if(key_data == 0)
            {
                key_state = KEY_RE_CONFIRM_INPUT;
            }
            else
            {
                key_state = KEY_WAIT_INPUT;
            }
            break;
        case KEY_RE_CONFIRM_INPUT://re-confirm key_input
            {    
                static uint8_t cnt=0;
                if(key_data == 0)
                {
                    if(key_time++ > 20)
                    {
                        key_time = 0;
                        cnt = 0;
                        signal = 1;
                        //sw1_flag = 1;
                        //按键标志
                        //key_state = KEY_RE_CONFIRM_INPUT;
                    }
                }
                else
                {
                    if(signal)
                    {
                        if(cnt++ > 5)
                        {
                            cnt=0;
                            signal=0;
                            sw1_flag = 1;
                            key_state = KEY_WAIT_INPUT;
                        }                        
                    }    
                }
            }
            break;
        default:
            break;
    }
}
/**
 * 按键2
 */
extern uint8_t sw2_flag;
void Scan_sw2(void)
{
    static uint16_t key_time2 = 0;
    static uint8_t key_state2 = 0;
    static uint8_t signal2 = 0;
    uint8_t key_data; 
    GPIO_SetBits(GPIOA, GPIO_Pin_1);
    key_data = GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1);
    switch(key_state2)
    {
        case KEY_WAIT_INPUT://wait key input
            if(key_data == 0)
                key_state2 = KEY_CONFIRM_INPUT;
            break;
        case KEY_CONFIRM_INPUT://confirm key input
            if(key_data == 0)
            {
                key_state2 = KEY_RE_CONFIRM_INPUT;
            }
            else
            {
                key_state2 = KEY_WAIT_INPUT;
            }
            break;
        case KEY_RE_CONFIRM_INPUT://re-confirm key_input
            {    
                static uint8_t cnt=0;
                if(key_data == 0)
                {
                    if(key_time2++ > 20)
                    {
                        key_time2 = 0;
                        cnt = 0;
                        signal2 = 1;
                        //按键标志
                        //key_state = KEY_RE_CONFIRM_INPUT;
                    }
                }
                else
                {
                    if(signal2)
                    {
                        if(cnt++ > 5)
                        {
                            cnt=0;
                            signal2=0;
                            sw2_flag = 1;
                            key_state2 = KEY_WAIT_INPUT;
                        }                        
                    }    
                }
            }
            break;
        default:
            break;
    }
}
/**
 * 按键3
 */
extern uint8_t sw3_flag;
void Scan_sw3(void)
{
    static uint16_t key_time3 = 0;
    static uint8_t key_state3 = 0;
    static uint8_t signal3 = 0;
    uint8_t key_data; 
    GPIO_SetBits(GPIOA, GPIO_Pin_2);
    key_data = GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_2);
    switch(key_state3)
    {
        case KEY_WAIT_INPUT://wait key input
            if(key_data == 0)
                key_state3 = KEY_CONFIRM_INPUT;
            break;
        case KEY_CONFIRM_INPUT://confirm key input
            if(key_data == 0)
            {
                key_state3 = KEY_RE_CONFIRM_INPUT;
            }
            else
            {
                key_state3 = KEY_WAIT_INPUT;
            }
            break;
        case KEY_RE_CONFIRM_INPUT://re-confirm key_input
            {    
                static uint8_t cnt=0;
                if(key_data == 0)
                {
                    if(key_time3++ > 20)
                    {
                        key_time3 = 0;
                        cnt = 0;
                        signal3 = 1;
                        //按键标志
                        //key_state = KEY_RE_CONFIRM_INPUT;
                    }
                }
                else
                {
                    if(signal3)
                    {
                        if(cnt++ > 5)
                        {
                            cnt=0;
                            signal3=0;
                            sw3_flag = 1;
                            key_state3 = KEY_WAIT_INPUT;
                        }                        
                    }    
                }
            }
            break;
        default:
            break;
    }
}
/**
 * 按键4
 */
extern uint8_t sw4_flag;
void Scan_sw4(void)
{
    static uint16_t key_time4 = 0;
    static uint8_t key_state4 = 0;
    static uint8_t signal4 = 0;
    uint8_t key_data; 
    GPIO_SetBits(GPIOA, GPIO_Pin_3);
    key_data = GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_3);
    switch(key_state4)
    {
        case KEY_WAIT_INPUT://wait key input
            if(key_data == 0)
                key_state4 = KEY_CONFIRM_INPUT;
            break;
        case KEY_CONFIRM_INPUT://confirm key input
            if(key_data == 0)
            {
                key_state4 = KEY_RE_CONFIRM_INPUT;
            }
            else
            {
                key_state4 = KEY_WAIT_INPUT;
            }
            break;
        case KEY_RE_CONFIRM_INPUT://re-confirm key_input
            {    
                static uint8_t cnt=0;
                if(key_data == 0)
                {
                    if(key_time4++ > 20)
                    {
                        key_time4 = 0;
                        cnt = 0;
                        signal4 = 1;
                        //按键标志
                        //key_state = KEY_RE_CONFIRM_INPUT;
                    }
                }
                else
                {
                    if(signal4)
                    {
                        if(cnt++ > 5)
                        {
                            cnt=0;
                            signal4=0;
                            sw4_flag = 1;
                            key_state4 = KEY_WAIT_INPUT;
                        }                        
                    }    
                }
            }
            break;
        default:
            break;
    }
}
/**
 * 按键5
 */
extern uint8_t sw5_flag;
void Scan_sw5(void)
{
    static uint16_t key_time5 = 0;
    static uint8_t key_state5 = 0;
    static uint8_t signal5 = 0;
    uint8_t key_data; 
    GPIO_SetBits(GPIOA, GPIO_Pin_4);
    key_data = GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_4);
    switch(key_state5)
    {
        case KEY_WAIT_INPUT://wait key input
            if(key_data == 0)
                key_state5 = KEY_CONFIRM_INPUT;
            break;
        case KEY_CONFIRM_INPUT://confirm key input
            if(key_data == 0)
            {
                key_state5 = KEY_RE_CONFIRM_INPUT;
            }
            else
            {
                key_state5 = KEY_WAIT_INPUT;
            }
            break;
        case KEY_RE_CONFIRM_INPUT://re-confirm key_input
            {    
                static uint8_t cnt=0;
                if(key_data == 0)
                {
                    if(key_time5++ > 20)
                    {
                        key_time5 = 0;
                        cnt = 0;
                        signal5 = 1;
                        //按键标志
                        //key_state = KEY_RE_CONFIRM_INPUT;
                    }
                }
                else
                {
                    if(signal5)
                    {
                        if(cnt++ > 5)
                        {
                            cnt=0;
                            signal5=0;
                            sw5_flag = 1;
                            key_state5 = KEY_WAIT_INPUT;
                        }                        
                    }    
                }
            }
            break;
        default:
            break;
    }
}

bsp_DMAusart1.h

#ifndef __BSP_DMAUSART1_H
#define    __BSP_DMAUSART1_H
//-------------------------------------------------------------------
//#include "main.h"
//#include "stm32f10x_dma.h"
#include "stm32f10x.h"
#include <string.h>
//-------------------------------------------------------------------
#define USART1_REC_LEN              58      //定义最大接收字节数 58
typedef struct
{
    uint8_t Tx_buf[USART1_REC_LEN];      //发送缓冲区
    uint8_t Tx_len;                      //发送长度
    uint8_t Rx_buf[USART1_REC_LEN];      //接收缓冲区
    uint8_t Rx_len;                      //接收长度
    uint8_t Rx_end_flag;              //接收完成标志
    uint8_t Rx_time_start;            //计时启动标志
    uint16_t Rx_time;                 //1祯数据接收时长(mSec) 
}USART1_DEF;
extern USART1_DEF OneUART;
//-------------------------------------------------------------------
void USART1_Init(uint32_t BAND,uint8_t *SendAddres,uint8_t *RecAddres,uint8_t len);
void DMA_USART1RxTx_Init(uint8_t *SendAd,uint8_t *RecAddres,uint8_t len);
void NVIC_USART1_Configuration(void);
void USART1_SendChar(u8 t);
void USART_printf(USART_TypeDef* USARTx, uint8_t *Data,...);
void USART1_SendString(void* buffer, uint16_t size);
void USART1_Encryption_SendString(void* buffer, uint16_t size);
uint16_t USART1_DMASendString(void* buffer, uint16_t size);
uint16_t USART1_Encryption_DMASendString(void* buffer, uint16_t size);
#endif /* __USART1_H */

bsp_DMAusart1.c

#include "bsp_DMAusart1.h"

USART1_DEF OneUART;
/**
* @brief  USART1初始化
* @param  BAND,波特率(2400,4800,9600,38400,115200)
*         Send_pf,发送数据缓冲区
*         Rec_pf,接收数据缓冲区
*         buf_len,接收数据缓冲区长度
* @retval 无
*/
void USART1_Init(uint32_t BAND,uint8_t *Send_pf,uint8_t *Rec_pf,uint8_t buf_len)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;

    /* config USART1 clock */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOB, ENABLE);

    /* USART1 GPIO config */

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);//使能端口重映射

    /* Configure USART1 Tx (PB6) as alternate function push-pull */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

    /* Configure USART1 Rx (PB7) as input floating */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

     /* RS485,Tx/Rx Control PB5 */
     GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_5;
     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     GPIO_Init(GPIOB, &GPIO_InitStructure);
    GPIO_ResetBits(GPIOB,GPIO_Pin_5);

    GPIO_PinRemapConfig(GPIO_Remap_USART1,ENABLE);    


    /* USART1 mode config */
    USART_InitStructure.USART_BaudRate = BAND;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No ;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

    USART_Init(USART1, &USART_InitStructure); 
    USART_Cmd(USART1, ENABLE);



    USART_ClearFlag(USART1, USART_FLAG_TC);             //清发送完成标志
    USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);        //开启空闲中断
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);        //开启接收中断
    USART_ITConfig(USART1, USART_IT_TC, ENABLE);        //开启发送完成中断
    NVIC_USART1_Configuration();

    DMA_USART1RxTx_Init(Send_pf,Rec_pf,buf_len);//DMA初始化

}


/**
* @brief  配置USART1中断
* @param  
* @retval 无
*/
static void NVIC_USART1_Configuration(void)
{
    NVIC_InitTypeDef NVIC_InitStructure; 
    /* Configure the NVIC Preemption Priority Bits */  
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);

    /* Enable the USARTy Interrupt */
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;         //开启接收完成中断
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);

    /* Enable the USARTy Interrupt */
    NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel4_IRQn;//开启发送完成中断 
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
}

/**
* @brief  DMA_USART1初始化
* @param  Send_pf,发送数据缓冲区
*         Rec_pf,接收数据缓冲区
*         buf_len,接收数据缓冲区长度
* @retval 无
*/
static void DMA_USART1RxTx_Init(uint8_t *Send_pf,uint8_t *Rec_pf,uint8_t buf_len)
{    
    DMA_InitTypeDef DMA_InitStructure;
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
    DMA_Cmd(DMA1_Channel5,DISABLE);                                             //关闭DMA
    DMA_DeInit(DMA1_Channel5);                                                    //恢复默认
    DMA_InitStructure.DMA_PeripheralBaseAddr=(u32)&USART1->DR;                    //设置串口发送数据寄存器            
    DMA_InitStructure.DMA_MemoryBaseAddr=(u32)Rec_pf;                             //设置发送缓冲区首地址        
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;                            //设置外设位目标，内存缓冲区 <- 外设寄存器
    DMA_InitStructure.DMA_BufferSize=buf_len;                                    //需要发送的字节数，这里其实可以设置为0，因为在实际要发送的时候，会重新设置次值
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;            //外设地址不递增
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;                        //内存递增
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;        //外设字节宽度
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;                //内存字节宽度
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;                                 //正常模式 
    DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;                        //高优先级
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;                                 //关闭内存到内存的DMA模式
    DMA_Init(DMA1_Channel5,&DMA_InitStructure);                                 //配置DMA1的6通道 
    DMA_Cmd(DMA1_Channel5,ENABLE);                                              //使能DMA

    DMA_DeInit(DMA1_Channel4);
    DMA_InitStructure.DMA_PeripheralBaseAddr= (u32)&USART1->DR;                    //初始化外设地址            
    DMA_InitStructure.DMA_MemoryBaseAddr=(u32)Send_pf;                             //内存地址        
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;                            //外设作为数据来源
    DMA_InitStructure.DMA_BufferSize=0;                                            //发送长度为0
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;            //外设地址不递增
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;                        //内存递增
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;        //外设字节宽度
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;                //内存字节宽度
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;                                 //正常模式 
    DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;                        //高优先级
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;                                 //关闭内存到内存的DMA模式    
    DMA_Init(DMA1_Channel4,&DMA_InitStructure);                                 //配置DMA1的7通道
    DMA_Cmd(DMA1_Channel4,ENABLE);                                              //使能DMA

    USART_ITConfig(USART1, USART_DMAReq_Tx, ENABLE);                               //开启中断USART_DMAReq_Tx
    USART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE);                                  //开启接收接收
    USART_DMACmd(USART1,USART_DMAReq_Tx,ENABLE);                                  //开启接收发送
//    DMA_ITConfig(DMA1_Channel4,DMA_IT_TC,ENABLE);                               //配置DMA发送完成后产生中断

}
 /**
  * @brief  USART1_DMA发送完成中断
  * @param  无
  * @retval 无
  */
void DMA1_Channel4_IRQHandler(void)
{
    if(DMA_GetFlagStatus(DMA1_FLAG_TC4)!=RESET)
    {//发送完成中断
        DMA_ClearFlag(DMA1_FLAG_TC4);
        //GPIO_ResetBits(GPIOB,GPIO_Pin_5);
    }
}
 /**
  * @brief  USART1串口接收中断
  * @param  无
  * @retval 无
  */
void USART1_IRQHandler(void)                    //串口1中断服务程序
{
    static uint8_t LEN = 0;
    uint8_t Clear = Clear,tmp;
    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) 
    {//接收中断     
        OneUART.Rx_buf[LEN++]= USART1->DR;            //读取接收到的数据
        LEN= (LEN < USART1_REC_LEN)?LEN:0;
    }else if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET)
    {//空闲中断，1桢数据接收完毕
        Clear=USART1->SR;    //读SR寄存器
        Clear=USART1->DR;    //读DR寄存器，(先读SR，再读DR就是清除IDLE标志中断)
        OneUART.Rx_end_flag  = 1;                //接收完成标志
        DMA_Cmd(DMA1_Channel5,DISABLE); 
        OneUART.Rx_len=USART1_REC_LEN-DMA_GetCurrDataCounter(DMA1_Channel5);
        DMA_SetCurrDataCounter(DMA1_Channel5,USART1_REC_LEN); //设置DMA缓冲区长度
        DMA_Cmd(DMA1_Channel5,ENABLE);    
    }else if(USART_GetITStatus(USART1, USART_IT_TC) != RESET)    
    {//发送完成中断 
        USART_ClearITPendingBit(USART1, USART_IT_TC);    //清除USART1发送完成中断标志
        DMA_ClearFlag(DMA1_FLAG_TC4);                    //清零标志位
        GPIO_ResetBits(GPIOB,GPIO_Pin_5);                //发送完成，等待接收数据

    }
}


 /**
  * @brief  DMA_USART1数据发送
  * @param  buffer,发送数据地址
  *         size,发送数据长度
  * @retval size
  */
uint16_t USART1_DMASendString(void* buffer, uint16_t size)
{
      if(!size) return 0;                                                    //判断长度是否有效
      while(DMA_GetCurrDataCounter(DMA1_Channel4));                            //检查DMA通道内是否还有数据
      if(buffer) //发送数据拷贝到发送缓存区
          memcpy(OneUART.Tx_buf, buffer,(size > 1024?1024:size));
      DMA_Cmd(DMA1_Channel4, DISABLE);                                        //DMA发送数据要先关闭，设置发送数据长度  开启DMA
      DMA1_Channel4->CNDTR = size;                                            //设置发送长度
      GPIO_SetBits(GPIOB,GPIO_Pin_5); 
      DMA_Cmd(DMA1_Channel4, ENABLE);                                          //启动DMA发送
      return size;
}

 /**
  * @brief  DMA_USART1加密数据发送
  * @param  buffer,发送数据地址
  *         size,发送数据长度
  * @retval size
  */
uint16_t USART1_Encryption_DMASendString(void* buffer, uint16_t size)
{
      if(!size) return 0;                                                    //判断长度是否有效
      while(DMA_GetCurrDataCounter(DMA1_Channel4));                            //检查DMA通道内是否还有数据
      if(buffer) //发送数据拷贝到发送缓存区
      {
          //encryption(buffer,size);//使能加密
          memcpy(OneUART.Tx_buf, buffer,(size > 1024?1024:size));    
      }     
      DMA_Cmd(DMA1_Channel4, DISABLE);                                        //DMA发送数据要先关闭，设置发送数据长度  开启DMA
      DMA1_Channel4->CNDTR = size;                                            //设置发送长度
      GPIO_SetBits(GPIOB,GPIO_Pin_5); 
      DMA_Cmd(DMA1_Channel4, ENABLE);                                          //启动DMA发送
      return size;
}

 /**
  * @brief  USART1发送数据1个字节
  * @param  dat,发送数据
  * @retval 无
  */
void  USART1_SendChar(u8 t)
{
    USART_SendData(USART1,t);
    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
    while((USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET));//等待串口发送完毕
}

 /**
  * @brief  USART1发送字符串
  * @param  dat,发送数据
  * @retval 无
  */
void USART1_SendString(void* buffer, uint16_t size)
{
    uint8_t i=0,*buf;
    buf=buffer;
     GPIO_SetBits(GPIOB,GPIO_Pin_5);  
     while(size--)
     {
         USART1_SendChar(buf[i++]);
     }
     GPIO_ResetBits(GPIOB,GPIO_Pin_5);
}

 /**
  * @brief  USART1加密发送字符串
  * @param  dat,发送数据
  * @retval 无
  */
void USART1_Encryption_SendString(void* buffer, uint16_t size)
{
    uint8_t i=0,*buf;
    //encryption(buffer,size);
    buf=buffer;
     GPIO_SetBits(GPIOB,GPIO_Pin_5);  
     while(size--)
     {
         USART1_SendChar(buf[i++]);
     }
     GPIO_ResetBits(GPIOB,GPIO_Pin_5);
}

bsp_nixie_tube.h

#ifndef __BSP_NIXIE_TUBE_H
#define __BSP_NIXIE_TUBE_H

#include "stm32f10x.h"

#define get_bit(dat, bit)    ((dat & (1<<bit))>>bit)
#define OPEN 1
#define CLOCK 0


// 关闭数码管
#define SET_TUBE_CLOSE()    GPIO_ResetBits(GPIOB, GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2);\
                            GPIO_ResetBits(GPIOA, GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_15);

//#define SET_TUBE_BLACK_B GPIO_ResetBits(GPIOB, GPIO_Pin_0 | GPIO_Pin_1);
//#define SET_TUBE_BLACK_A GPIO_ResetBits(GPIOA, GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_15);

// 数码管片选开关
#define     CHIP_1(OPEN_OR_CLOCK)    if(OPEN_OR_CLOCK)     GPIO_ResetBits(GPIOA, GPIO_Pin_5);\
                                                                else GPIO_SetBits(GPIOA, GPIO_Pin_5)
#define     CHIP_2(OPEN_OR_CLOCK)    if(OPEN_OR_CLOCK)     GPIO_ResetBits(GPIOA, GPIO_Pin_6);\
                                                                else GPIO_SetBits(GPIOA, GPIO_Pin_6)
#define     CHIP_3(OPEN_OR_CLOCK)    if(OPEN_OR_CLOCK)     GPIO_ResetBits(GPIOA, GPIO_Pin_7);\
                                                                else GPIO_SetBits(GPIOA, GPIO_Pin_7)
#define     CHIP_4(OPEN_OR_CLOCK)    if(OPEN_OR_CLOCK)     GPIO_ResetBits(GPIOA, GPIO_Pin_8);\
                                                                else GPIO_SetBits(GPIOA, GPIO_Pin_8)

// 点亮数码管
#define     SET_TUBE_LIGHT(num) \
                                GPIO_SetBits(GPIOA, \
                                    ((get_bit(num, 0) << 9)) | /*GPIO_Pin_9  a*/ \
                                    ((get_bit(num, 1) << 10)) | /*GPIO_Pin_10  b*/ \
                                    ((get_bit(num, 2) << 11)) | /*GPIO_Pin_11  c*/ \
                                    ((get_bit(num, 3) << 12)) | /*GPIO_Pin_12  d*/ \
                                    ((get_bit(num, 4) << 15)));/*GPIO_Pin_15  e*/ \
                                GPIO_SetBits(GPIOB, (get_bit(num, 5) << 0) | /*GPIO_Pin_0 f*/ \
                                                    (get_bit(num, 6) << 1)  /*GPIO_Pin_1 g*/ );  //   


void Nixie_Tube_GPIO_Config(void);
void Show_Number(uint16_t number, uint8_t isOpen, uint8_t isOpenPoint);

#endif // __BSP_NIXIE_TUBE_H

bsp_nixie_tube.c

#include "bsp_nixie_tube.h"

// 共阳数码管真值表 0 1 2 3 4 5 6 7 8 9 A b C d E F H L ^ U P
uint8_t smgduan[21] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,
                                           0x88,0x83,0xC6,0xA1,0x86,0x8E,0x89, 0xC7, 0xC8, 0xC1,0x8C};


// 初始化GPIO引脚
void Nixie_Tube_GPIO_Config(void)
{

    GPIO_InitTypeDef  GPIO_InitStruct;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB, ENABLE);


    // 配置5个按键的引脚
    GPIO_InitStruct.GPIO_Pin = (GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8 |GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_15 | GPIO_Pin_12);

    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP; // 推挽输出
    GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP; // 推挽输出
    GPIO_InitStruct.GPIO_Pin = (GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2);// | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_8 | GPIO_Pin_9);
    GPIO_Init(GPIOB, &GPIO_InitStruct);

}


// 点亮数码管
void SET_Tube_Light(uint8_t num)
{
    SET_TUBE_LIGHT(num);
}


extern uint8_t nixit_tube1;
// 数码管上显示的数据
void Show_Number(uint16_t number, uint8_t isOpen, uint8_t isOpenPoint)
{
    static uint8_t n1 = 0;
    static uint8_t n2 = 0;
    static uint8_t n3 = 0;
    static uint8_t n4 = 0;

    // 取数值
    uint8_t number_4 = smgduan[number % 10];
    uint8_t number_3 = smgduan[(number/10) % 10];
    uint8_t number_2 = smgduan[((number/10)/10) % 10];
    uint8_t number_1 = smgduan[number/1000];


//    uint8_t number_4 = smgduan[number & 0x0f];
//    uint8_t number_3 = smgduan[(number >> 4) & 0x0f];
//    uint8_t number_2 = smgduan[(number >> 8) & 0x0f];
//    uint8_t number_1 = smgduan[(number >> 12) & 0x0f];
    //GPIO_ResetBits(GPIOB, GPIO_Pin_2);
    //GPIO_SetBits(GPIOB, GPIO_Pin_2);
    // 第一个开始亮
    if(nixit_tube1 == 1)
    {
        // 关闭上一个
        SET_TUBE_CLOSE();
        CHIP_4(CLOCK);

        // 打开当前
        CHIP_1(OPEN);
        SET_TUBE_LIGHT(number_1);

        if( !get_bit(isOpenPoint, 3) ) // 数码管下的点是否开启
            GPIO_SetBits(GPIOB, GPIO_Pin_2);
    }

    // 第二个开始亮
    if(nixit_tube1 == 2)
    {
        // 关闭上一个
        SET_TUBE_CLOSE();
        CHIP_1(CLOCK);

        // 打开当前
        CHIP_2(OPEN);
        SET_TUBE_LIGHT(number_2);// SET_Tube(number_2);

        if( !get_bit(isOpenPoint, 2) )
            GPIO_SetBits(GPIOB, GPIO_Pin_2);
    }


    if(nixit_tube1 == 3)
    {
        SET_TUBE_CLOSE();
        CHIP_2(CLOCK);

        CHIP_3(OPEN);
        SET_TUBE_LIGHT(number_3); // SET_Tube(number_3);

        if( !get_bit(isOpenPoint, 1) )
            GPIO_SetBits(GPIOB, GPIO_Pin_2);
    }

    if(nixit_tube1 == 4)
    {

        SET_TUBE_CLOSE();
        CHIP_3(CLOCK);

        CHIP_4(OPEN);
        SET_TUBE_LIGHT(number_4); // SET_Tube(number_4);

        if( !get_bit(isOpenPoint, 0) )
            GPIO_SetBits(GPIOB, GPIO_Pin_2);
    }

}

bsp_crc.h

#ifndef __BSP_CRC_H
#define __BSP_CRC_H

#include "stm32f10x.h"


uint16_t crc16ForModbus(uint8_t *data, uint16_t size);

#endif //__BSP_CRC_H

bsp_crc.h

#include "bsp_crc.h"


uint16_t crc16ForModbus(uint8_t *data, uint16_t size)
{
    static const uint16_t crc16Table[] =
    {
        0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
        0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
        0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
        0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
        0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
        0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
        0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
        0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
        0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
        0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
        0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
        0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
        0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
        0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
        0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
        0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
        0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
        0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
        0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
        0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
        0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
        0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
        0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
        0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
        0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
        0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
        0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
        0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
        0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
        0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
        0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
        0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
    };

    uint8_t buf;
    uint16_t crc16 = 0xFFFF;

    for ( uint16_t i = 0; i < size; ++i )
    {
        buf = data[i] ^ crc16;
        crc16 >>= 8;
        crc16 ^= crc16Table[ buf ];
    }

    return (crc16>>8 | crc16<<8);
}

main.c

/**********************
芯片：STM32F103C8T6

实现功能：

引脚：
***********************/

#include "stm32f10x.h"
#include "main.h"
#include "bsp_DMAusart1.h"
#include "bsp_tim3.h"
#include "bsp_key.h"
#include "bsp_nixie_tube.h"
#include "bsp_crc.h"


extern void Scan_sw1(void);    
extern void Scan_sw2(void);    
extern void Scan_sw3(void);    
extern void Scan_sw4(void);    
extern void Scan_sw5(void);    
extern uint8_t Scan_key_flag;


int main()
{

    uint8_t a = 0;  

    uint8_t twinkle = 0x0f; // 4个数码管亮灭控制

    static uint16_t timCount = 0; // 计数


    USART1_Init(9600, OneUART.Tx_buf, OneUART.Rx_buf, USART1_REC_LEN);
    USART1_DMASendString("AppStart!", sizeof("AppStart!"));



    TIM3_Int_Init(71,999);
    //KEY_GPIO_Config();  // 初始化按键的GPIO
    //Nixie_Tube_GPIO_Config();  // 初始化数码管GPIO
    //USART1_Init(9600, OneUART.Tx_buf, OneUART.Rx_buf, USART1_REC_LEN);  // 初始化USART1
    //TIM3_Int_Init(9999, 71); // 1ms

    while(1)
    {
        // 检测按键
        if(Scan_key_flag)
        {
            change++; // 实时显示数据跳动
            if(change > 3000)
            {
                change = 0;
            }

            if(timCount == 0)
            {
                Test2++;
            }
            timCount++;     // 发送数据计时


            // 数码管计时
            nixit_tube1++;    
            if(nixit_tube1 > 4) nixit_tube1 =1;

            // 按键扫描
            Scan_key_flag=0;
            Scan_sw1();
            Scan_sw2();
            Scan_sw3();
            Scan_sw4();
            Scan_sw5(); 

            // 数码管显示
            Show_Number(data, twinkle, isOpenPoint); // 4个参数控制数码管亮灭 1 1 1 1

            // 长时间未按按键则跳回实时显示状态
            back_jump_realData_flag++;
        }

        if((OneUART.Rx_buf[0] == 0x08) && (OneUART.Rx_buf[1] == 0x03) && (OneUART.Rx_len > 8))
        {
            // 当按键连续按的时候，则不再更新数据
            if(time_key_flag >= 2)
            {
                time_key_flag = 0;
                OneLiftData = (OneUART.Rx_buf[3] << 8) | OneUART.Rx_buf[4]; // 将目前的数据赋值到要变化的数据
                OneConveyorData = (OneUART.Rx_buf[5] << 8) | OneUART.Rx_buf[6];
                TwoLiftData = (OneUART.Rx_buf[7] << 8) | OneUART.Rx_buf[8];
                TwoConveyorData = (OneUART.Rx_buf[9] << 8) | OneUART.Rx_buf[10];
            }
        }

        switch(flag_status)
        {
            case enum_REAL_TIMER_DATA: // 实时显示数据
                realTime();
                break;
            case enum_OneLifterDelayStatTime: // 1号罐升降机延时启动时间
                //data = (OneUART.Rx_buf[3] << 8) | OneUART.Rx_buf[4];
                data = OneLiftData;
                isOpenPoint = 0x08;
                break;
            case enum_OneConveyorCloseDelayTime: // 1号传送带关闭延迟时间
                //data = (OneUART.Rx_buf[5] << 8) | OneUART.Rx_buf[6];
                data = OneConveyorData;
                isOpenPoint = 0x08;
                break;
            case enum_TwoLifterDelayStatTime: // 2号罐升降机延时启动时间
                //data = (OneUART.Rx_buf[7] << 8) | OneUART.Rx_buf[8];
                data = TwoLiftData;
                isOpenPoint = 0x04;
                break;
            case enum_TwoConveyorCloseDelayTime: // 2号传送带关闭延迟时间
                //data = (OneUART.Rx_buf[9] << 8) | OneUART.Rx_buf[10];
                data = TwoConveyorData;
                isOpenPoint = 0x04;
                break;
            case enum_SET_WAIT_Status: // 设置等待状态
                data = 2222;
                isOpenPoint = 0x0f;
                break;
            case enum_SET_Reset:         // 复位
                data = 9999;
                isOpenPoint = 0x0f;
                break;
            case enum_SET_Def:              // 恢复出厂设置
                data = 7777;
                isOpenPoint = 0x0f;
                break;
            case enum_OneDelayTim:         // 切换状态至1号罐升降机延时启动时间
                data = 1177;
                isOpenPoint = 0x08;
                break;
            case enum_OneCloseDelayTim: // 切换状态至1号传送带关闭延迟时间
                data = 1188;
                isOpenPoint = 0x08;
                break;
            case enum_TwoDelayTim:         // 切换状态至2号罐升降机延时启动时间
                data = 2277;
                isOpenPoint = 0x04;
                break;
            case enum_TwoCloseDelayTim: // 切换状态至2号传送带关闭延迟时间
                data = 2288;
                isOpenPoint = 0x04;
                break;
            case enum_InputSetDef:         // 切换状态至复位
                data = 3333;
                isOpenPoint = 0x0f;
                break;
            case enum_InputFactorySet: // 切换状态至出厂设置
                data = 4444;
                isOpenPoint = 0x0f;
                break;
            default:
                break;
        }


        // 发送数据出去
        if( OneUART.Rx_end_flag) // 判断是否可以发送数据
        {// 实时数据
            uint16_t crc; // CRC校验
            uint8_t *buffer;

            // 判断是否接收到的数据为02开头的数据
            if(OneUART.Rx_buf[0] == 0x01) //  || (OneUART.Rx_buf[0] == 0x01)
            { // 实时数据

                if(timCount> 680) // 延迟发送时间
                {
                    time_key_flag++;
                    Test++;
                    buffer = readData; // 要向设备发送的数据
                    crc = crc16ForModbus(buffer, TxDataSize);

                    buffer[6] = crc >>8;  // 高8位
                    buffer[7] = (uint8_t)crc; // 低8位

                    OneUART.Rx_end_flag = 0;
                    timCount = 0;

                    USART1_DMASendString(buffer, TxDataSize + 2);
                    *OneUART.Rx_buf = 0;

                }
            }
            else if(OneUART.Rx_buf[0] == 0x02)
            { // 控制指令

                if(timCount > 710) // 延迟发送时间 850
                {
                    if(send_flag == 1) // 复位
                    {

                        send_flag = 0;
                        buffer = DefVal;
                        crc = crc16ForModbus(buffer, TxDataSize);
                        buffer[6] = crc >>8;  // 高8位
                        buffer[7] = (uint8_t)crc; // 低8位

                        OneUART.Rx_end_flag = 0;
                        timCount = 0;

                        USART1_DMASendString(buffer, TxDataSize + 2);
                        *OneUART.Rx_buf = 0;
                    }
                    else if(send_flag == 2) // 恢复出厂设置
                    {
                        send_flag = 0;
                        buffer = factorySet;


                        crc = crc16ForModbus(buffer, TxDataSize);

                        buffer[6] = crc >>8;  // 高8位
                        buffer[7] = (uint8_t)crc; // 低8位

                        OneUART.Rx_end_flag = 0;
                        timCount = 0;

                        USART1_DMASendString(buffer, TxDataSize + 2);
                        *OneUART.Rx_buf = 0;
                    }
                    else if(send_flag == 3)    // 1号罐升降机延时启动时间
                    {
                        send_flag = 0;
                        buffer = OneStartTime;

                        buffer[4] = (uint8_t) OneLiftData>>8;
                        buffer[5] = (uint8_t) OneLiftData;
                        crc = crc16ForModbus(buffer, TxDataSize);

                        buffer[6] = crc >>8;  // 高8位
                        buffer[7] = (uint8_t)crc; // 低8位

                        OneUART.Rx_end_flag = 0;
                        timCount = 0;

                        USART1_DMASendString(buffer, TxDataSize + 2);
                        *OneUART.Rx_buf = 0;
                    }
                    else if(send_flag == 4) // 1号传送带关闭延迟时间
                    {
                        send_flag = 0;
                        buffer = OneDelayTime;

                        buffer[4] = (uint8_t) OneConveyorData>>8;
                        buffer[5] = (uint8_t) OneConveyorData;
                        crc = crc16ForModbus(buffer, TxDataSize);

                        buffer[6] = crc >>8;  // 高8位
                        buffer[7] = (uint8_t)crc; // 低8位

                        OneUART.Rx_end_flag = 0;
                        timCount = 0;

                        USART1_DMASendString(buffer, TxDataSize + 2);
                        *OneUART.Rx_buf = 0;
                    }
                    else if(send_flag == 5) // 2号罐升降机延时启动时间
                    {
                        send_flag = 0;
                        buffer = TwoStartTime;

                        buffer[4] = (uint8_t) TwoLiftData>>8;
                        buffer[5] = (uint8_t) TwoLiftData;
                        crc = crc16ForModbus(buffer, TxDataSize);

                        buffer[6] = crc >>8;  // 高8位
                        buffer[7] = (uint8_t)crc; // 低8位

                        OneUART.Rx_end_flag = 0;
                        timCount = 0;

                        USART1_DMASendString(buffer, TxDataSize + 2);
                        *OneUART.Rx_buf = 0;
                    }
                    else if(send_flag == 6) // 2号传送带关闭延迟时间
                    {
                        send_flag = 0;
                        buffer = TwoDelayTime;

                        buffer[4] = (uint8_t) TwoConveyorData>>8;
                        buffer[5] = (uint8_t) TwoConveyorData;
                        crc = crc16ForModbus(buffer, TxDataSize);

                        buffer[6] = crc >>8;  // 高8位
                        buffer[7] = (uint8_t)crc; // 低8位

                        OneUART.Rx_end_flag = 0;
                        timCount = 0;

                        USART1_DMASendString(buffer, TxDataSize + 2);
                        *OneUART.Rx_buf = 0;
                    }
                    else
                    {
                        *OneUART.Rx_buf = 0;
                        OneUART.Rx_end_flag = 0;
                        timCount = 0;
//                        USART1_DMASendString("tim", sizeof("tim"));
                    }

                }
            }
        }

        if(back_jump_realData_flag == 10000)
        {
            back_jump_realData_flag = 0;
            key_status1 = 0;
            key_status2 = 0;
            key_status3 = 0;
            key_status4 = 0;
            key_status5 = 0;
        }


         // 按了按键1    -------- 设置键 等待设置
         if( sw1_flag)
         {

             sw1_flag = 0;
             key_status1++;
             if(key_status1 == 2)
             {
                 // 退出设置
                 key_status1 = 0;
             }

             key_status2 = 0;
             key_status3 = 0;
             key_status4 = 0;
             key_status5 = 0;
             back_jump_realData_flag = 0;

         }

         // 按了按键5 --------- 确认设置
         if( sw5_flag)
         {
             sw5_flag = 0;
             if(key_status5 == 4)
             {
                 key_status5 = 3;
             }
             key_status5++;
             back_jump_realData_flag = 0;
         }

         // 按了按键4 ---------- 切换
         if( sw4_flag)
         {
             sw4_flag = 0;
             key_status4++;
             key_status5 = 3;
             if(key_status4 == 6)
             {
                 key_status4 = 0;
             }
             back_jump_realData_flag = 0;
         }

         // 按了按键3 ---------- 减按键
         if( sw3_flag )
         {
             a--;
             sw3_flag = 0;
             key_status3 = 1;
             back_jump_realData_flag = 0;
         }

         // 按了按键2 ---------- 加按键
         if( sw2_flag )
         {
             a++;
             sw2_flag = 0;
             key_status2 = 1;
             back_jump_realData_flag = 0;
         }

         // 数码管显示
        tube_dataShow();

    }

}

// 数码管数据显示
void tube_dataShow(void)
{
     if(key_status1 == 1)
     {// 进入设置

         if(key_status5 == 1 || key_status5 >= 3)
         {// 进入确定设置

             if(key_status4 == 0)
             {// 进入切换 1号罐升降机启动时间

                 if(key_status5 == 4)
                 {// 进入确认设置

                     if(key_status2 == 1)
                     {
                         // 加操作
                         key_status2 = 0;
                         send_flag = 3;
                         OneLiftData++;
                         time_key_flag = 0;
                     }

                     if(key_status3 == 1)
                     {
                         // 减操作
                         key_status3 = 0;
                         send_flag = 3;
                         OneLiftData--;
                         time_key_flag = 0;
                     }
                     //data = OneLiftData;
                     flag_status = enum_OneLifterDelayStatTime;
                     return;
                 }
                 flag_status = enum_OneDelayTim; 
                 return;
                 //break;
             }else if(key_status4 == 1)
             {
                 // 进入切换 1号传送带关闭延时时间
                 if(key_status5 == 4)
                 {// 进入确认设置

                     if(key_status2 == 1)
                     {
                         // 加操作
                         key_status2 = 0;
                         send_flag = 4;
                         OneConveyorData++;
                         time_key_flag = 0;
                     }

                     if(key_status3 == 1)
                     {
                         // 减操作
                         key_status3 = 0;
                         send_flag = 4;
                         OneConveyorData--;
                         time_key_flag = 0;
                     }
                     //data = OneConveyorData;
                     flag_status = enum_OneConveyorCloseDelayTime;
                     return;
                 }
                 flag_status = enum_OneCloseDelayTim;
                 return;

             }else if(key_status4 == 2)
             {
                 // 进入切换 2号罐升降机启动时间
                 if(key_status5 == 4)
                 {// 进入确认设置


                     if(key_status2 == 1)
                     {
                         // 加操作
                         key_status2 = 0;
                         send_flag = 5;
                         TwoLiftData++;
                         time_key_flag = 0;
                     }

                     if(key_status3 == 1)
                     {
                         // 减操作
                         key_status3 = 0;
                         send_flag = 5;
                         TwoLiftData--;
                         time_key_flag = 0;
                     }
                     //data = TwoLiftData;
                     flag_status = enum_TwoLifterDelayStatTime;
                     return;
                 }
                 flag_status = enum_TwoDelayTim; 
                 return;

             }else if(key_status4 == 3)
             {
                 // 进入切换 2号传送带关闭延时时间
                 if(key_status5 == 4)
                 {// 进入确认设置 


                     if(key_status2 == 1)
                     {
                         // 加操作
                         key_status2 = 0;
                         send_flag = 6;
                         TwoConveyorData++;
                         time_key_flag = 0;
                     }

                     if(key_status3 == 1)
                     {
                         // 减操作
                         key_status3 = 0;
                         send_flag = 6;
                         TwoConveyorData--;
                         time_key_flag = 0;
                     }
                     //data = TwoConveyorData;
                     flag_status = enum_TwoConveyorCloseDelayTime;
                     return;
                 }
                 flag_status = enum_TwoCloseDelayTim; 
                 return;

             }else if(key_status4 == 4)
             {
                 // 进入切换 复位
                 if(key_status5 == 4)
                 {// 进行确认
                     key_status5 = 3;
                     send_flag = 1; // 确认发送默认值 Confirm_sendData_DefVal

                 }
                 //data = 3333;
                 flag_status = enum_InputSetDef; 
                 return;

             }else if(key_status4 == 5)
             {
                 // 进入切换 恢复出厂设置
                 if(key_status5 == 4)
                 {// 进行确认

                     send_flag = 2;
                     key_status5 = 3;

                 }
                 //data = 4444;
                 flag_status = enum_InputFactorySet;
                return;                 
             }

         }else if(key_status5 == 2)
         {
            key_status5 =4;
            key_status4 = 0;
         }
         flag_status = enum_SET_WAIT_Status; // 进入设置等待状态

     }else
     {
         // 显示实时数据
         flag_status = enum_REAL_TIMER_DATA;
     }
}

/* 
 * 实时显示
 *
 */
void realTime(void)
{

    if((change >= 0) && (change <= 1500))
    {
        data = (OneUART.Rx_buf[11] << 8) | OneUART.Rx_buf[12]; // 1号
        isOpenPoint = 0x08;
    }
    else if((change > 1500) && (change <= 3000))
    {
        data = (OneUART.Rx_buf[13] << 8) | OneUART.Rx_buf[14]; // 2号
        isOpenPoint = 0x04;
    }
}

Config_init.h

#ifndef __CONFIG_INIT_H
#define __CONFIG_INIT_H
#include "stm32f10x.h"

void Config_init();
#endif /* __CONFIG_INIT_H */

Config_init.c

#include "Config_init.h"

void Config_init()
{
    //USART1_Init(115200, OneUART.Tx_buf, OneUART.Rx_buf, USART1_REC_LEN);
    Nixie_Tube_GPIO_Config();  //Nixie_Tube_GPIO_Config();  
    KEY_GPIO_Config();  // 初始化按键的GPIO
}

stm32f10x_sdio.c (放下面这段代码为了重定向JATG)

int $Sub$$main(void)
{
     GPIO_InitTypeDef  GPIO_InitStructure;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);                            
    GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable,ENABLE);                                
    GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);    
    Config_init();

  $Super$$main(); 

}

system_stm32f10x.c或者加上这段

GPIO_InitTypeDef  GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);                            

GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable,ENABLE);                                
GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);