```C
#ifndef __STM32_MAIN_H
#define __STM32_MAIN_H

#include "stm32f10x.h"
#include "sys.h"
#include "DigitalTube.h"
#include "wdg.h"
#include "dma.h"		
#include "lcd.h"		
#include "EXTI.h"
#include "Register_config.h"
#include "game.h"
void LED_Configuration(void);
void LED_Blink(void);
void One_LED_ON(unsigned char led_num);
void One_LED_OFF(unsigned char led_num);
void LED_TURN(void);
	
void BEEP_Configuration(void);
void Beep(void);

void KEY_Configuration(void);
void Count_KEY_Init(void);
int  KEY_read(void);
void key_test(void);
u8 KEY_Scan(void);

void uart_test(void);
void uart1_init(void);

void IWDG_test(void);

void AI_Configuration(void);
void DAC1_Configuration(void);
void AIAO_test(void);

void LCD_Configuration(void);
void LCD_test(void);
void Touch_test(void);		

void Counter_test(void);

void PWM_Configuration(u16 arr,u16 psc);
void PWM_test(void);

void DMA_test(void);
void DMA_test1(void);

void ENC25Q80_SPI2_Init(void);
u32 SPI_FLASH_ReadDeviceID(void);

void IIC_Configuration(void);
void IIC_test(void);

void delay_init(u8 SYSCLK);
void delay_s(u16 ns);
void delay_ms(u16 nms);
void delay_us(u32 nus);
#endif
/******END OF FILE****/
```


```C
main函数：
    {
       // RS232_test();    // uart.c ???????
			  USART1_SendByte('0x55');   // MCU ???
		//	USART1_SendFrame(tx_frame, sizeof(tx_frame) - 1);
      //  for(int i=0;i<10000;i++);
			 //  if (FrameFlag)
       //{
         //  FrameFlag = 0;
            
          // RXPos = 0;
       // }
    }
UART.c
#include "UART.H"

#include "stm32f10x.h"
#include <stm32f10x_usart.h>
#include "stdio.h"
#include "stdint.h"


void RS232_Configuration(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
 	USART_InitTypeDef USART_InitStructure; 
	//Òý½ÅʱÖÓ,
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	//´®¿ÚʱÖÓ,USART1¹Ò½ÓÔÚAPB2×ÜÏßÉÏ
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
	//»¹ÐèÒª¿ªÆô¸´Óù¦ÄܵÄʱÖÓ
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);

  /*
  *
	USART1_TX -> PA9 ¸´ÓÃÍÆÍìÊä³ö,ÒòΪ²»Êǽ«GIPIOʹÓöøÊÇUART´®¿ÚÀ´Ê¹ÓÃ,
	USART1_RX ->	PA10 ¸¡¿ÕÊäÈëģʽ£¬²»ÄÜʹÄÜÉÏÀ­»òÕßÏÂÀ­µç×è
  */				
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;	         
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; 
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
  GPIO_Init(GPIOA, &GPIO_InitStructure);		   

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;	        
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //È¥µôҲû¹Øϵ
  GPIO_Init(GPIOA, &GPIO_InitStructure);
	
		//´®¿Ú1³õʼ»¯
	USART_InitStructure.USART_BaudRate = 115200;
	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
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//ÒòΪ²»ÖªµÀʲôʱºò½ÓÊÕËùÒÔ²ÉÓÃÖжϵķ½Ê½
	USART_ITConfig(USART1, USART_IT_TC, ENABLE);//¿ÕÏÐÖжϣ¬Êý¾Ý·¢Ë͵ÄÄÜÁ¿ºÜÉÙ£¬ËùÒÔ²ÉÓÃ×èÈûµÄ·½Ê½
	USART_ClearITPendingBit(USART1, USART_IT_TC);//Çå³ýÖжÏTCλ
	USART_Cmd(USART1, ENABLE);
	
}

void NVIC_Configuration(void)
{
  NVIC_InitTypeDef   NVIC_InitStructure;

  /* Set the Vector Table base location at 0x08000000 */
  NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);

  /* 2 bit for pre-emption priority, 2 bits for subpriority */
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); 
  
  /* Enable the Ethernet global Interrupt */
  
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;	  
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;	
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
	//Èç¹û»¹ÓÐÆäËûÖжϣ¬°´ÕÕÏÂÃæÀàËƵÄÔö¼Ó¼´¿É
//	NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;	  
//	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;
//	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;	
//	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
//	NVIC_Init(&NVIC_InitStructure); 
}
/***********************************************************************
º¯ÊýÃû³Æ£ºvoid USART1_IRQHandler(void) 
¹¦    ÄÜ£ºÍê³ÉSCIµÄÊý¾ÝµÄ½ÓÊÕ£¬²¢×ö±êʶ
ÊäÈë²ÎÊý£º
Êä³ö²ÎÊý£º
±àдʱ¼ä£º2012.11.22
±à д ÈË£º
×¢    Òâ  RS485ÓõÄÊÇUSART3.
***********************************************************************/


u8 RS232InData;
#define USART_BUF_LEN  			200  	//¶¨Òå×î´ó½ÓÊÕ×Ö½ÚÊý 200
u8 USART_Rxbuf[USART_BUF_LEN];     //½ÓÊÕ»º³å,×î´óUSART_BUF_LEN¸ö×Ö½Ú.
u8 USART_Txbuf[USART_BUF_LEN];     //·¢ËÍ»º³å,×î´óUSART_BUF_LEN¸ö×Ö½Ú.
volatile u16 RXPos=0;
volatile u16 FrameFlag = 0;
volatile u16 RecvTimeOver=10;
u16 SendPos,SendBufLen;
uint16_t TxPos = 0;
uint16_t TxLen = 0;

void USART1_IRQHandler(void)  
{
		if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //½ÓÊÕÖжÏ
		{
			if(RXPos<=USART_BUF_LEN)//»º³åÇøδÂú
			{
				USART_Rxbuf[RXPos]=USART_ReceiveData(USART1);//(USART1->DR);	//¶ÁÈ¡½ÓÊÕµ½µÄÊý¾Ý ;
				RXPos++;
			}
			RecvTimeOver = 10 ;  //ÿ´Î½ÓÊÕµ½Êý¾Ý£¬³¬Ê±¼ì²âʱ¼ä10ms
    } 	
		
	//	if (USART_GetITStatus(USART1, USART_IT_TC) != RESET) 
	//	{
		//		USART_ClearITPendingBit(USART1, USART_IT_TC);           /* Clear the USART transmit interrupt       */
			//  if ( SendPos < SendBufLen )
			//	{
			//		USART_SendData(USART1,USART_Txbuf[SendPos]);
			//		SendPos ++ ;
				//}
					//·¢ËÍÊý¾Ý
			//	UART1->DR = data ;
		//}
			    /* ????:TXE(?????) */
    if (USART_GetITStatus(USART1, USART_IT_TXE) != RESET)
    {USART_ClearITPendingBit(USART1, USART_IT_TC);  
        if (TxPos < TxLen)
        {
            USART_SendData(USART1, USART_Txbuf[TxPos++]);
        }
        else
        {
            USART_ITConfig(USART1, USART_IT_TXE, DISABLE); // ? ??????
        }
    }
}


void RS232_test()
{
		if ( FrameFlag != 0 )
		{
				//¶Ô½ÓÊÕµ½µÄÊý¾Ý½øÐд¦Àí
				//¿ÉÒÔ¶¨Òå·¢ËÍÊý¾ÝÖ¡£¬²¢Æô¶¯·¢ËÍ¡£Èç¹û³õʼ»¯µÄʱºò¿ªÆôUSART_IT_TCÖжϣ¬Ôòÿ·¢ËÍÒ»¸ö×Ö½Ú½øÈëÒ»´ÎÖжÏ
				//ͨ¹ý½øÈëÖжϵļÆÊýÆ÷£¬È·¶¨¸Ã·¢ËÍ·¢ËÍÖ¡ÖеÄÄĸö×Ö½Ú£¬Ö±µ½·¢ÍêΪֹ
				FrameFlag = 0 ;
		}
		
		
	

}
void USART1_SendFrame(uint8_t *buf, uint16_t len)
{
    memcpy(USART_Txbuf, buf, len);
    TxLen = len;
    TxPos = 0;

    USART_ITConfig(USART1, USART_IT_TXE, ENABLE); // ????
}
void USART1_SendByte(uint8_t data)
{
    USART_SendData(USART1, data);
    while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
}


void uart1_init()	
{
		RS232_Configuration();		
	NVIC_Configuration();

}
```

```C
uint8_t CRC8_Calc(uint8_t *buf, uint8_t len)
{
    uint8_t crc = 0x00;
    for (uint8_t i = 0; i < len; i++)
    {
        crc ^= buf[i];
        for (uint8_t j = 0; j < 8; j++)
        {
            if (crc & 0x80)
                crc = (crc << 1) ^ 0x07;
            else
                crc <<= 1;
        }
    }
    return crc;
}为什么我卡在了这一步？
```

```C
if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
   {
       uint8_t ch = USART_ReceiveData(USART1);

       switch (uart_state)
       {
       case UART_WAIT_HEAD1:
           if (ch == 0xAA)
           {
               RXPos = 0;
               USART_Rxbuf[RXPos++] = ch;
               uart_state = UART_WAIT_HEAD2;
           }
           break;

       case UART_WAIT_HEAD2:
           if (ch == 0x55)
           {
               USART_Rxbuf[RXPos++] = ch;
               uart_state = UART_WAIT_LEN;
           }
           else
           {
               uart_state = UART_WAIT_HEAD1;
           }
           break;

       case UART_WAIT_LEN:
           if (ch >= 1 && ch <= 4)
           {
               data_len = ch;
               data_cnt = 0;
               USART_Rxbuf[RXPos++] = ch;
               uart_state = UART_WAIT_DATA;
           }
           else
           {
               uart_state = UART_WAIT_HEAD1;
           }
           break;

       case UART_WAIT_DATA:
           if (RXPos < USART_BUF_LEN)
               USART_Rxbuf[RXPos++] = ch;
           data_cnt++;
           if (data_cnt >= data_len)
               uart_state = UART_WAIT_CRC;
           break;

       case UART_WAIT_CRC:
           rx_crc = ch;
           if (CRC8_Calc(USART_Rxbuf, RXPos) == rx_crc)
               FrameFlag = 1; // ??????
           uart_state = UART_WAIT_HEAD1;
           break;
       }
   }



   if (FrameFlag)
       {
           FrameFlag = 0;
           // ?????
           uint8_t sum = 0;
           for (uint8_t i = 0; i < data_len; i++)
               sum += USART_Rxbuf[3 + i]; // ?????3??

           // ?????
           tx_reply[0] = 0xAA;
           tx_reply[1] = 0x40;
           tx_reply[2] = sum;
           tx_reply[3] = CRC8_Calc(tx_reply, 3);

           // ??????
           USART1_SendFrame(tx_reply, 4);

           RXPos = 0; // ???????
   }
```

```C
void SysTick_Handler(void)
{
  /* Update the LocalTime by adding SYSTEMTICK_PERIOD_MS each SysTick interrupt */
	time_handle();
	 tickCount++; 
 		if (RecvTimeOver)
{
    RecvTimeOver--;
    if (RecvTimeOver == 0 && RXPos > 0)
    {
        FrameFlag = 1;   // ??????
    }
}
}



// 超时处理函数，需要在主循环中每10ms调用一次
void UART_TimeoutHandler(void)
{
    if (RecvTimeOver > 0)
    {
        RecvTimeOver--;
        if (RecvTimeOver == 0)
        {
            // 超时发生，复位状态机
            uart_state = UART_WAIT_HEAD1;
            RXPos = 0;
            TimeoutFlag = 1;
        }
    }
}
```