[mw_shl_code=applescript,true]        #include "sys.h"
        #include "usart.h"          

//加入以下代码,支持printf函数,而不需要选择use MicroLIB          
#if 1
#pragma import(__use_no_semihosting)            
//标准库需要的支持函数                 
struct __FILE
{
        int handle;

};

FILE __stdout;      
//定义_sys_exit()以避免使用半主机模式   
_sys_exit(int x)
{
        x = x;
}
//重定义fputc函数
int fputc(int ch, FILE *f)
{      
        while((USART1->SR&0X40)==0);//循环发送,直到发送完毕   
    USART1->DR = (u8) ch;      
        return ch;
}
#endif
        u8 i=0;
        u8 usart_rx_buf[64];    //接收缓冲,最大64个字节u8 usart_rx_buf[5][64];
        u8 usart_rx_temporary[64]; //数据保存暂存器,最多能够缓存64个字节
//        u8 usartrxbuf_pagebuf=0;         //最上面接受缓存的页码（5）缓存
        u8 usart_rd_len=0;         //有用信息的数据长度
        u8 usart_rd_lentemp=0;           //用来记录已读取的数据长度
        u8 usart_rx_enableflag=0;  //接收状态标记         
        u8 usart_rx_lenrightflag=0;//数据长度校验位正确标志
        u8 usart_rx_successflag=0; //成功接收到数据信息
        u8 usart_cmd=0x01;   //命令码

        void uart_init(u32 bound)
                {       
                        GPIO_InitTypeDef GPIO_InitStructure;
                        USART_InitTypeDef USART_InitStructure;
                        NVIC_InitTypeDef NVIC_InitStructure;
                         
                        RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1，GPIOA时钟
                        USART_DeInit(USART1);                                                                                                                                                 //复位串口1
                        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;                                                                        //PA.9//USART1_TX   PA.9
                        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
                        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                                                //复用推挽输出
                        GPIO_Init(GPIOA, &GPIO_InitStructure);                                                                                 //初始化PA9
                       
                        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;                                                                //USART1_RX          PA.10
                        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;                        //浮空输入
                        GPIO_Init(GPIOA, &GPIO_InitStructure);                                                                                 //初始化PA10

                        USART_InitStructure.USART_BaudRate = bound;                                                                //一般设置为9600;
                        USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
                        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);                                                                 //初始化串口
                        NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
                        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;        //抢占优先级3
                        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                                //子优先级3
                        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                                                //IRQ通道使能
                        NVIC_Init(&NVIC_InitStructure);                                                                                                                //根据指定的参数初始化VIC寄存器
                         
                        USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);                                                //开启中断
                        USART_Cmd(USART1, ENABLE);                                                                    //使能串口
                }

        /******************************************************************************************/               
        /*                                                                                                                        自定义串口数据收发数据校验                                                                                                                                */               
        /*                串口每次发送一个字节（一个八位二进制数），没接受一个字节，串口中断一次，就执行一次串*/
        /*口中断函数。                                                                                                                                                                                                                                                                                                                */
        /*串口数据校验                                (包头0x68)(数据长度)(命令码)(...数据...)(校验和)(包尾0x16)                                                */
        /*                每一个括号代表一个字节，而数据括号待变N个字节                                                                                                                                                                */
        /******************************************************************************************/               
        void USART1_IRQHandler(void)                                                                                        //串口1中断服务程序
                {
                        u8 i,res,check_temp;
                        if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)                  //接收中断，每接收一个字节（8位二进制数据），中断一次,每次中断（即每接收一个数据）都执行一次下列程序
                                {
                                        res=USART_ReceiveData(USART1);                                                                                                //读取接收到的数据
                                        if((res==0x68)&&(usart_rx_enableflag==0))                                                        //当接受到命令头(0x68)数据并且还没有成功接收完数据信息
                                                usart_rx_enableflag=1;                                                                                                                        //说明这是命令头，启动接收数据标志，进入数据接收阶段
                                       
                                        if(usart_rx_enableflag==1)                                                                                                                //到接受数据标志置位时，接受数据
                                                {                       
                                                        res=USART_ReceiveData(USART1);                                                                                //读取串口标志
                                                        if(usart_rd_lentemp==0)                                                                                                                //命令头后第一个数据为需要传输的数据的长度
                                                                {
                                                                        usart_rd_len=res;                                                                                                                        //读取数据的长度
                                                                        if(usart_rd_len>=60)
                                                                        {
                                                                                usart_rx_lenrightflag=0;                                                                                //数据长度校验清零
                                                                                usart_rx_successflag=0;                                                                                        //数据接收成功标志清零
                                                                                usart_rx_enableflag=0;                                                                                        //数据接收完成，数据接收启动标志清零
                                                                                usart_rd_len=0;                                                                                                                        //数据长度清零
                                                                                usart_rd_lentemp=0;                                                                                                        //数据长度暂存器清零                                                                                                                                                               
                                                                        }
                                                                }
                                                        else if(usart_rd_lentemp==1)                                        //命令头后第2个数据为命令码
                                                        {
                                                                usart_cmd=res;
                                                                if(usart_cmd!=0x00&&usart_cmd!=0x01&&usart_cmd!=0x02)
                                                                {
                                                                                usart_cmd=0;                                                                                                                                //清除命令码
                                                                                usart_rx_lenrightflag=0;                                                                                //数据长度校验清零
                                                                                usart_rx_successflag=0;                                                                                        //数据接收成功标志清零
                                                                                usart_rx_enableflag=0;                                                                                        //数据接收完成，数据接收启动标志清零
                                                                                usart_rd_len=0;                                                                                                                        //数据长度清零
                                                                                usart_rd_lentemp=0;                                                                                                        //数据长度暂存器清零                       
                                                                }
                                                        }
                                                               
                                                        else if(usart_rd_lentemp==usart_rd_len+2)                                //当读取到第usart_rd_lentemp+1个数据时，校验是否是长度信息的反码
                                                                {
                                                                        check_temp=check_temp-usart_rx_temporary[2];                                                                                        //取数据长度校验位的反码123
                                                                        if(res==check_temp)                                                                                                                //当数据长度校验正确时
                                                                                usart_rx_lenrightflag=1;                                                                                //数据长度校验标志置一
                                                                        else                                                                                                                                                                        
                                                                        {                                                                                                                                                                                        //当数据校验和校验错误时
                                                                                usart_cmd=0;                                                                                                                                //清除命令码                                                                               
                                                                                usart_rx_lenrightflag=0;                                                                                //数据长度校验清零
                                                                                usart_rx_successflag=0;                                                                                        //数据接收成功标志清零
                                                                                usart_rx_enableflag=0;                                                                                        //当数据长度校验错误时，数据接收启动标志清零
                                                                                usart_rd_len=0;                                                                                                                        //数据长度清零
                                                                                usart_rd_lentemp=0;                                                                                           //数据长度暂存器清零
                                                                        }
                                                                }
                                                        else if(usart_rd_lentemp==usart_rd_len+3)                                        //当读取到第usart_rd_lentemp+2个数据时，校验包尾是否正确
                                                                {
                                                                        if((res==0x16)&&(usart_rx_lenrightflag==1))                //如果包尾数据与长度校验都正确
                                                                        {
                                                                                usart_rx_lenrightflag=0;                                                                                //数据长度校验清零
                                                                                usart_rx_successflag=1;                                                                                        //数据接收成功标志置一
                                                                                usart_rx_enableflag=0;                                                                                        //数据接收完成，数据接收启动标志清零
                                                                                usart_rd_len=0;                                                                                                                        //数据长度清零
                                                                                usart_rd_lentemp=0;                                                                                                 //数据长度暂存器清零                                                                               
                                                                        }
                                                                        else
                                                                        {                                                                                                                                                                                        //当包尾数据校验错误时
                                                                                usart_cmd=0;                                                                                                                                //清除命令码                               
                                                                                usart_rx_lenrightflag=0;                                                                                //数据长度校验清零
                                                                                usart_rx_successflag=0;                                                                                        //数据接收成功标志清零
                                                                                usart_rx_enableflag=0;                                                                                        //数据接收完成，数据接收启动标志清零
                                                                                usart_rd_len=0;                                                                                                                        //数据长度清零
                                                                                usart_rd_lentemp=0;                                                                                                        //数据长度暂存器清零                                                                               
                                                                        }
                                                                }
                                                        else
                                                        {
                                                                check_temp=check_temp+res;                  //校验和
                                                                usart_rx_temporary[usart_rd_lentemp-1]=res;        //当usart_rd_lentemp为数据段时，将数据存到串口数据接收寄存器中
                                                        }
                                                usart_rd_lentemp++;                                                                                                                                        //每次记录数据，数据长度暂存器自加       
                                                if(usart_rx_successflag==1)                                                                                                        //如果成功接收到信息数据，将缓存usart_rx_temporary[]内的数据传递给usart_rx_buf[][]
                                                        {
                                                                for(i=0;i<usart_rd_len;i++)
                                                                        usart_rx_buf=usart_rx_temporary;
//                                                                usartrxbuf_pagebuf++;                                                                                                                //接受缓存的页码缓存自加
//                                                                if(usartrxbuf_pagebuf==5) usartrxbuf_pagebuf=0;        //接受缓存的页码缓存最大为5
//                                                                usartrxbuf_pagebuf++;
                                                        }                       
                                        }
                         }
}
               
               
               
               
               
                [/mw_shl_code]