发新帖我要提问
1234下一页
返回列表
打印
[STM32F1]

关于 STM32F103的串口1,2,3,4,5总计5个串口的案例！<申请原创.....

[复制链接]
楼主: 東南博士
手机看帖
扫描二维码
随时随地手机跟帖
21楼
東南博士|  楼主 | 2018-8-3 09:50 | 只看该作者 回帖奖励 |倒序浏览
/*****************  发送一个16位数 **********************/
void Usart_SendHalfWord( USART_TypeDef * pUSARTx, uint16_t ch)
{
    uint8_t temp_h, temp_l;

    /* 取出高八位 */
    temp_h = (ch&0XFF00)>>8;
    /* 取出低八位 */
    temp_l = ch&0XFF;

    /* 发送高八位 */
    USART_SendData(pUSARTx,temp_h);
    while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);

    /* 发送低八位 */
    USART_SendData(pUSARTx,temp_l);
    while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
}

使用特权

评论回复 赏
22楼
東南博士|  楼主 | 2018-8-3 09:50 | 只看该作者
///重定向c库函数printf到串口，重定向后可使用printf函数
int fputc(int ch, FILE *f)
{
    /* 发送一个字节数据到串口 */
    USART_SendData(UART3_USARTx, (uint8_t) ch);
    /* 等待发送完毕 */
    while (USART_GetFlagStatus(UART3_USARTx, USART_FLAG_TXE) == RESET);
    return (ch);
}

使用特权

评论回复 赏
23楼
東南博士|  楼主 | 2018-8-3 09:50 | 只看该作者
///重定向c库函数scanf到串口，重写向后可使用scanf、getchar等函数
int fgetc(FILE *f)
{
    /* 等待串口输入数据 */
    while (USART_GetFlagStatus(UART3_USARTx, USART_FLAG_RXNE) == RESET);
    return (int)USART_ReceiveData(UART3_USARTx);
}

使用特权

评论回复 赏
24楼
東南博士|  楼主 | 2018-8-3 09:51 | 只看该作者
// 串口中断服务函数
void UART1_UART_IRQHandler(void)
{
    volatile unsigned int Uart_stateus = 0;

    if(USART_GetITStatus(UART1_USARTx,USART_IT_RXNE)!=RESET)
    {

        //数据缓冲转换
        if(UART1_Flag.Buf_Now==Buf_A) //现在用的是Buf_A，则使用Buf_B
        {
            UART1_Flag.USER_USART_RX_Buf_A[UART1_Flag.Num_Rx] = USART_ReceiveData(UART1_USARTx);
            UART1_Flag.Num_Rx++;
        }
        else    //现在用的是Buf_B，则使用Buf_A
        {
            UART1_Flag.USER_USART_RX_Buf_B[UART1_Flag.Num_Rx] = USART_ReceiveData(UART1_USARTx);
            UART1_Flag.Num_Rx++;
        }
    }

    if(USART_GetITStatus(UART1_USARTx,USART_IT_IDLE)!=RESET)
    {

        Uart_stateus = UART1_USARTx->SR;
        Uart_stateus = UART1_USARTx->DR; //清除串口空闲接受中断

        if(UART1_Flag.Buf_Now==Buf_A) //现在用的是Buf_A，则使用Buf_B
        {
            UART1_Flag.Buf_Now=Buf_B;
        }
        else
        {
            UART1_Flag.Buf_Now=Buf_A;
        }
        UART1_Flag.IDLE_FLAG=SET;
    }
}

使用特权

评论回复 赏
25楼
東南博士|  楼主 | 2018-8-3 09:52 | 只看该作者
// 串口中断服务函数
void UART2_UART_IRQHandler(void)
{
    volatile unsigned int Uart_stateus = 0;

    if(USART_GetITStatus(UART2_USARTx,USART_IT_RXNE)!=RESET)
    {

        //数据缓冲转换
        if(UART2_Flag.Buf_Now==Buf_A) //现在用的是Buf_A，则使用Buf_B
        {
            UART2_Flag.USER_USART_RX_Buf_A[UART2_Flag.Num_Rx] = USART_ReceiveData(UART2_USARTx);
            UART2_Flag.Num_Rx++;
        }
        else    //现在用的是Buf_B，则使用Buf_A
        {
            UART2_Flag.USER_USART_RX_Buf_B[UART2_Flag.Num_Rx] = USART_ReceiveData(UART2_USARTx);
            UART2_Flag.Num_Rx++;
        }
    }

    if(USART_GetITStatus(UART2_USARTx,USART_IT_IDLE)!=RESET)
    {

        Uart_stateus = UART2_USARTx->SR;
        Uart_stateus = UART2_USARTx->DR; //清除串口空闲接受中断

        if(UART2_Flag.Buf_Now==Buf_A) //现在用的是Buf_A，则使用Buf_B
        {
            UART2_Flag.Buf_Now=Buf_B;
        }
        else
        {
            UART2_Flag.Buf_Now=Buf_A;
        }
        UART2_Flag.IDLE_FLAG=SET;
    }
}

使用特权

评论回复 赏
26楼
東南博士|  楼主 | 2018-8-3 09:53 | 只看该作者
// 串口中断服务函数
void UART3_UART_IRQHandler(void)
{
    volatile unsigned int Uart_stateus = 0;

    if(USART_GetITStatus(UART3_USARTx,USART_IT_RXNE)!=RESET)
    {

        //数据缓冲转换
        if(UART3_Flag.Buf_Now==Buf_A) //现在用的是Buf_A，则使用Buf_B
        {
            UART3_Flag.USER_USART_RX_Buf_A[UART3_Flag.Num_Rx] = USART_ReceiveData(UART3_USARTx);
            UART3_Flag.Num_Rx++;
        }
        else    //现在用的是Buf_B，则使用Buf_A
        {
            UART3_Flag.USER_USART_RX_Buf_B[UART3_Flag.Num_Rx] = USART_ReceiveData(UART3_USARTx);
            UART3_Flag.Num_Rx++;
        }
    }

    if(USART_GetITStatus(UART3_USARTx,USART_IT_IDLE)!=RESET)
    {

        Uart_stateus = UART3_USARTx->SR;
        Uart_stateus = UART3_USARTx->DR; //清除串口空闲接受中断

        if(UART3_Flag.Buf_Now==Buf_A) //现在用的是Buf_A，则使用Buf_B
        {
            UART3_Flag.Buf_Now=Buf_B;
        }
        else
        {
            UART3_Flag.Buf_Now=Buf_A;
        }
        UART3_Flag.IDLE_FLAG=SET;
    }
}

使用特权

评论回复 赏
27楼
東南博士|  楼主 | 2018-8-3 09:54 | 只看该作者
// 串口中断服务函数
void UART4_UART_IRQHandler(void)
{
    volatile unsigned int Uart_stateus = 0;

    if(USART_GetITStatus(UART4_USARTx,USART_IT_RXNE)!=RESET)
    {

        //数据缓冲转换
        if(UART4_Flag.Buf_Now==Buf_A) //现在用的是Buf_A，则使用Buf_B
        {
            UART4_Flag.USER_USART_RX_Buf_A[UART4_Flag.Num_Rx] = USART_ReceiveData(UART4_USARTx);
            UART4_Flag.Num_Rx++;
        }
        else    //现在用的是Buf_B，则使用Buf_A
        {
            UART4_Flag.USER_USART_RX_Buf_B[UART4_Flag.Num_Rx] = USART_ReceiveData(UART4_USARTx);
            UART4_Flag.Num_Rx++;
        }
    }

    if(USART_GetITStatus(UART4_USARTx,USART_IT_IDLE)!=RESET)
    {

        Uart_stateus = UART4_USARTx->SR;
        Uart_stateus = UART4_USARTx->DR; //清除串口空闲接受中断

        if(UART4_Flag.Buf_Now==Buf_A) //现在用的是Buf_A，则使用Buf_B
        {
            UART4_Flag.Buf_Now=Buf_B;
        }
        else
        {
            UART4_Flag.Buf_Now=Buf_A;
        }
        UART4_Flag.IDLE_FLAG=SET;
    }
}

使用特权

评论回复 赏
28楼
東南博士|  楼主 | 2018-8-3 09:54 | 只看该作者
// 串口中断服务函数
void UART5_UART_IRQHandler(void)
{
    volatile unsigned int Uart_stateus = 0;

    if(USART_GetITStatus(UART5_USARTx,USART_IT_RXNE)!=RESET)
    {

        //数据缓冲转换
        if(UART5_Flag.Buf_Now==Buf_A) //现在用的是Buf_A，则使用Buf_B
        {
            UART5_Flag.USER_USART_RX_Buf_A[UART5_Flag.Num_Rx] = USART_ReceiveData(UART5_USARTx);
            UART5_Flag.Num_Rx++;
        }
        else    //现在用的是Buf_B，则使用Buf_A
        {
            UART5_Flag.USER_USART_RX_Buf_B[UART5_Flag.Num_Rx] = USART_ReceiveData(UART5_USARTx);
            UART5_Flag.Num_Rx++;
        }
    }

    if(USART_GetITStatus(UART5_USARTx,USART_IT_IDLE)!=RESET)
    {

        Uart_stateus = UART5_USARTx->SR;
        Uart_stateus = UART5_USARTx->DR; //清除串口空闲接受中断

        if(UART5_Flag.Buf_Now==Buf_A) //现在用的是Buf_A，则使用Buf_B
        {
            UART5_Flag.Buf_Now=Buf_B;
        }
        else
        {
            UART5_Flag.Buf_Now=Buf_A;
        }
        UART5_Flag.IDLE_FLAG=SET;
    }
}

使用特权

评论回复 赏
29楼
東南博士|  楼主 | 2018-8-3 10:01 | 只看该作者
以上程序 是 结构体定义，5个串口的初始化，中断

使用的中断方式为：

    // 使能串口接收中断
    USART_ITConfig(UART1_USARTx,USART_IT_TC,DISABLE);  //关闭发送完成中断
    USART_ITConfig(UART1_USARTx,USART_IT_RXNE,ENABLE);  //关闭接收中断
    USART_ITConfig(UART1_USARTx,USART_IT_IDLE,ENABLE);//开启总线空闲中断

使用特权

评论回复 赏
30楼
東南博士|  楼主 | 2018-8-3 10:35 | 只看该作者
//检测帧头，返回位置
unsigned char Cheack_FrameHead(unsigned char Find_buf_long,unsigned char BUF[]);

void Progress_UART1(void);
void Progress_UART2(void);
void Progress_UART3(void);
void Progress_UART4(void);
void Progress_UART5(void);

extern void Date_Progress_Uart1(void);
extern void Date_Progress_Uart2(void);
extern void Date_Progress_Uart3(void);
extern void Date_Progress_Uart4(void);
extern void Date_Progress_Uart5(void);


extern void TASK_PRJ_UART1(void);
extern void TASK_PRJ_UART2(void);
extern void TASK_PRJ_UART3(void);
extern void TASK_PRJ_UART4(void);
extern void TASK_PRJ_UART5(void);

使用特权

评论回复 赏
31楼
東南博士|  楼主 | 2018-8-3 10:36 | 只看该作者
对于 函数的处理

使用特权

评论回复 赏
32楼
東南博士|  楼主 | 2018-8-3 10:37 | 只看该作者
//查找帧头并返回位置；
unsigned char Cheack_FrameHead(unsigned char Find_buf_long,unsigned char BUF[])
{
    volatile unsigned char Find_head_point=0XFF;
    volatile unsigned char Find_cnt=0;
    //从BUF中检索数据；
    for(Find_cnt=0; Find_cnt<Find_buf_long; Find_cnt++)
    {
        //判断4个连接的数据是不是"SIEW"；
        if(
            (BUF[Find_cnt+0]==HEAD1)&&
            (BUF[Find_cnt+1]==HEAD2)&&
            (BUF[Find_cnt+2]==HEAD3)&&
            (BUF[Find_cnt+3]==HEAD4)
        )
        {
            //首次出现的位置赋值；
            Find_head_point=Find_cnt;
            //跳出检索for循环；
            break;
        }
    }
    //返回数据
    return Find_head_point;
}//END_static unsigned char Cheack_Head_SIEW(unsigned char BUF[])

使用特权

评论回复 赏
33楼
東南博士|  楼主 | 2018-8-3 10:37 | 只看该作者
//解析用户协议
static unsigned int Crack_User_data(USART_TypeDef * pUSARTx,unsigned char BUF[],unsigned char Find_point)
{
    //长度与长度位置
    volatile unsigned char Frame_LONG=0;
    volatile unsigned char Frame_LONG_point=0XFF;
    //功能与功能位置
    volatile unsigned char Frame_FUN=0;
    volatile unsigned char Frame_FUN_point=0XFF;
    //校验与校验位置
    volatile unsigned char CRC_TMP=0;
    volatile unsigned char CRC_TMP_point=0XFF;
    volatile unsigned char CRC_CNT=0;
    volatile unsigned char CRC_DAT=0;

    //全局功能状态
    volatile unsigned int  STEP_SYS_TMP=0;

    //长度与长度位置
    Frame_LONG_point=Find_point+4;
    Frame_LONG=BUF[Frame_LONG_point];
//    printf("Frame_LONG_point @%d;Frame_LONG@%d;\r\n",Frame_LONG_point,Frame_LONG);

    //功能与功能位置
    Frame_FUN_point=Find_point+5;
    Frame_FUN=BUF[Frame_FUN_point];
//    printf("Frame_FUN_point @%d;Frame_FUN@%d;\r\n",Frame_FUN_point,Frame_FUN);

    //校验与校验位置
    CRC_TMP_point=Frame_LONG-1-1;
    CRC_TMP=BUF[CRC_TMP_point];
//    printf("CRC_TMP_point @%d;CRC_TMP@%d;\r\n",CRC_TMP_point,CRC_TMP);

    //将有效数据位赋值到缓冲数组中
    for(unsigned char RCV_CNT=0; RCV_CNT<Frame_LONG; RCV_CNT++)
    {
        if(pUSARTx==UART1_USARTx)
        {
            UART1_Flag.RCV_BUF[RCV_CNT]=BUF[RCV_CNT];
            printf("RCV_BUF[%d]=@%d;%d\r\n",RCV_CNT,UART1_Flag.RCV_BUF[RCV_CNT],BUF[RCV_CNT]);
        }
        if(pUSARTx==UART2_USARTx)
        {
            UART2_Flag.RCV_BUF[RCV_CNT]=BUF[RCV_CNT];
            printf("RCV_BUF[%d]=@%d;%d\r\n",RCV_CNT,UART2_Flag.RCV_BUF[RCV_CNT],BUF[RCV_CNT]);
        }
        if(pUSARTx==UART3_USARTx)
        {
            UART3_Flag.RCV_BUF[RCV_CNT]=BUF[RCV_CNT];
            printf("RCV_BUF[%d]=@%d;%d\r\n",RCV_CNT,UART3_Flag.RCV_BUF[RCV_CNT],BUF[RCV_CNT]);
        }
        if(pUSARTx==UART4_USARTx)
        {
            UART4_Flag.RCV_BUF[RCV_CNT]=BUF[RCV_CNT];
            printf("RCV_BUF[%d]=@%d;%d\r\n",RCV_CNT,UART4_Flag.RCV_BUF[RCV_CNT],BUF[RCV_CNT]);
        }
        if(pUSARTx==UART5_USARTx)
        {
            UART5_Flag.RCV_BUF[RCV_CNT]=BUF[RCV_CNT];
            printf("RCV_BUF[%d]=@%d;%d\r\n",RCV_CNT,UART5_Flag.RCV_BUF[RCV_CNT],BUF[RCV_CNT]);
        }

    }

    for(CRC_CNT=0; CRC_CNT<Frame_LONG-2; CRC_CNT++)
    {
        CRC_DAT+=User_BUF[CRC_CNT];
    }
//    printf("CRC_DAT @%d-%d;\r\n",CRC_TMP,CRC_DAT);

    //功能码的解析,并且校验校验字，注意校验位的位数是第几位
    switch(Frame_FUN)
    {
    case 1://001,查询
        if(CRC_DAT==CRC_TMP)
        {
            STEP_SYS_TMP=1;
        }
        else
        {
            STEP_SYS_TMP=Sys_CRC_ERROR;
        }
        break;

    case 2://002,开关
        if(CRC_DAT==CRC_TMP)
        {
            Power_switch_DAT=User_BUF[Find_point+5+1];
            BD_AP1_DAT=User_BUF[Find_point+5+2];
            ZZW_AP1_DAT=User_BUF[Find_point+5+3];
            ZZW_AP2_DAT=User_BUF[Find_point+5+4];
            //
            STEP_SYS_TMP=2;
        }
        else
        {
            STEP_SYS_TMP=Sys_CRC_ERROR;
        }
        break;

    case 3://指令3
        if(CRC_DAT==CRC_TMP)
        {
            STEP_SYS_TMP=3;
        }
        else
        {
            STEP_SYS_TMP=Sys_CRC_ERROR;
        }
        break;

    case 4://指令4
        if(CRC_DAT==CRC_TMP)
        {
            STEP_SYS_TMP=4;
        }
        else
        {
            STEP_SYS_TMP=Sys_CRC_ERROR;
        }
        break;

    case 5://指令5
        if(CRC_DAT==CRC_TMP)
        {
            STEP_SYS_TMP=5;
        }
        else
        {
            STEP_SYS_TMP=Sys_CRC_ERROR;
        }
        break;

    case 6://指令6
        if(CRC_DAT==CRC_TMP)
        {
            STEP_SYS_TMP=6;
        }
        else
        {
            STEP_SYS_TMP=Sys_CRC_ERROR;
        }
        break;

    case 7://指令7
        if(CRC_DAT==CRC_TMP)
        {
            STEP_SYS_TMP=7;
        }
        else
        {
            STEP_SYS_TMP=Sys_CRC_ERROR;
        }
        break;

    case 8://指令8
        if(CRC_DAT==CRC_TMP)
        {
            STEP_SYS_TMP=8;
        }
        else
        {
            STEP_SYS_TMP=Sys_CRC_ERROR;
        }
        break;

    case 9://指令9
        if(CRC_DAT==CRC_TMP)
        {
            STEP_SYS_TMP=9;
        }
        else
        {
            STEP_SYS_TMP=Sys_CRC_ERROR;
        }
        break;

    default:
        STEP_SYS_TMP=Sys_CRC_ERROR;
        break;
    }
    //返回数据
    return STEP_SYS_TMP;
}

使用特权

评论回复 赏
34楼
東南博士|  楼主 | 2018-8-3 10:37 | 只看该作者
//查找并检索用户协议
void Progress_UART1(void)
{
    UART1_Flag.Head_point=0XFF;
    //当前使用数组缓冲A
    if(UART1_Flag.Buf_Now==Buf_A)
    {
        //从B中检索数据
        UART1_Flag.Head_point=Cheack_FrameHead(UART1_Flag.Num_Rx,UART1_Flag.USER_USART_RX_Buf_B);
        /******在这里加入：校验数据帧的函数—开始*******/
        if(UART1_Flag.Head_point!=0XFF)//检索到了SIEW的位置
        {
            /******数据处理函数_START*******/
            UART1_Flag.SYS_STEP_UART=Crack_User_data(UART1_USARTx,UART1_Flag.USER_USART_RX_Buf_B,UART1_Flag.Head_point);
            /******数据处理函数_END*******/
        }
        //数据无效，进入IDLE模式
        if(UART1_Flag.Head_point==0XFF)
        {
            UART1_Flag.SYS_STEP_UART=Sys_IDLE;
        }
        /******在这里加入：校验数据帧的函数—结束*******/
    }
    //当前使用数组缓冲B
    if(UART1_Flag.Buf_Now==Buf_B)
    {
        //从B中检索数据
        UART1_Flag.Head_point=Cheack_FrameHead(UART1_Flag.Num_Rx,UART1_Flag.USER_USART_RX_Buf_A);
        /******在这里加入：校验数据帧的函数—开始*******/
        if(UART1_Flag.Head_point!=0XFF)//检索到了SIEW的位置
        {
            /******数据处理函数_START*******/
            UART1_Flag.SYS_STEP_UART=Crack_User_data(UART1_USARTx,UART1_Flag.USER_USART_RX_Buf_A,UART1_Flag.Head_point);
            /******数据处理函数_END*******/
        }
        //数据无效，进入IDLE模式
        if(UART1_Flag.Head_point==0XFF)
        {
            UART1_Flag.SYS_STEP_UART=Sys_IDLE;
        }
        /******在这里加入：校验数据帧的函数—结束*******/
    }
    //处理完成后，对接收的数据进行复位
    UART1_Flag.Num_Rx=0;
    //处理完成后，对位置的数据进行复位
    UART1_Flag.Head_point=0XFF;
}//END_void Copy_buf(void)

使用特权

评论回复 赏
35楼
東南博士|  楼主 | 2018-8-3 10:55 | 只看该作者
//查找并检索用户协议
void Progress_UART2(void)
{
    UART2_Flag.Head_point=0XFF;
    //当前使用数组缓冲A
    if(UART2_Flag.Buf_Now==Buf_A)
    {
        //从B中检索数据
        UART2_Flag.Head_point=Cheack_FrameHead(UART2_Flag.Num_Rx,UART2_Flag.USER_USART_RX_Buf_B);
        /******在这里加入：校验数据帧的函数—开始*******/
        if(UART2_Flag.Head_point!=0XFF)//检索到了SIEW的位置
        {
            /******数据处理函数_START*******/
            UART2_Flag.SYS_STEP_UART=Crack_User_data(UART2_USARTx,UART2_Flag.USER_USART_RX_Buf_B,UART2_Flag.Head_point);
            /******数据处理函数_END*******/
        }
        //数据无效，进入IDLE模式
        if(UART2_Flag.Head_point==0XFF)
        {
            UART2_Flag.SYS_STEP_UART=Sys_IDLE;
        }
        /******在这里加入：校验数据帧的函数—结束*******/
    }
    //当前使用数组缓冲B
    if(UART2_Flag.Buf_Now==Buf_B)
    {
        //从B中检索数据
        UART2_Flag.Head_point=Cheack_FrameHead(UART2_Flag.Num_Rx,UART2_Flag.USER_USART_RX_Buf_A);
        /******在这里加入：校验数据帧的函数—开始*******/
        if(UART2_Flag.Head_point!=0XFF)//检索到了SIEW的位置
        {
            /******数据处理函数_START*******/
            UART2_Flag.SYS_STEP_UART=Crack_User_data(UART2_USARTx,UART2_Flag.USER_USART_RX_Buf_A,UART2_Flag.Head_point);
            /******数据处理函数_END*******/
        }
        //数据无效，进入IDLE模式
        if(UART2_Flag.Head_point==0XFF)
        {
            UART2_Flag.SYS_STEP_UART=Sys_IDLE;
        }
        /******在这里加入：校验数据帧的函数—结束*******/
    }
    //处理完成后，对接收的数据进行复位
    UART2_Flag.Num_Rx=0;
    //处理完成后，对位置的数据进行复位
    UART2_Flag.Head_point=0XFF;
}//END_void Copy_buf(void)

使用特权

评论回复 赏
36楼
東南博士|  楼主 | 2018-8-3 10:55 | 只看该作者
//查找并检索用户协议
void Progress_UART3(void)
{
    UART3_Flag.Head_point=0XFF;
    if(UART3_Flag.Buf_Now==Buf_A)
    {
        //从B中检索数据
        UART3_Flag.Head_point=Cheack_FrameHead(UART3_Flag.Num_Rx,UART3_Flag.USER_USART_RX_Buf_B);
        /******在这里加入：校验数据帧的函数—开始*******/
        if(UART3_Flag.Head_point!=0XFF)//检索到了SIEW的位置
        {
            /******数据处理函数_START*******/
            UART3_Flag.SYS_STEP_UART=Crack_User_data(UART3_USARTx,UART3_Flag.USER_USART_RX_Buf_B,UART3_Flag.Head_point);
            /******数据处理函数_END*******/
        }
        //数据无效，进入IDLE模式
        if(UART3_Flag.Head_point==0XFF)
        {
            UART3_Flag.SYS_STEP_UART=Sys_IDLE;
        }
        /******在这里加入：校验数据帧的函数—结束*******/
    }
    //当前使用数组缓冲B
    if(UART3_Flag.Buf_Now==Buf_B)
    {
        //从B中检索数据
        UART3_Flag.Head_point=Cheack_FrameHead(UART3_Flag.Num_Rx,UART3_Flag.USER_USART_RX_Buf_A);
        /******在这里加入：校验数据帧的函数—开始*******/
        if(UART3_Flag.Head_point!=0XFF)//检索到了SIEW的位置
        {
            /******数据处理函数_START*******/
            UART3_Flag.SYS_STEP_UART=Crack_User_data(UART3_USARTx,UART3_Flag.USER_USART_RX_Buf_A,UART3_Flag.Head_point);
            /******数据处理函数_END*******/
        }
        //数据无效，进入IDLE模式
        if(UART3_Flag.Head_point==0XFF)
        {
            UART3_Flag.SYS_STEP_UART=Sys_IDLE;
        }
        /******在这里加入：校验数据帧的函数—结束*******/
    }
    //处理完成后，对接收的数据进行复位
    UART3_Flag.Num_Rx=0;
    //处理完成后，对位置的数据进行复位
    UART3_Flag.Head_point=0XFF;
}//END_void Copy_buf(void)

使用特权

评论回复 赏
37楼
東南博士|  楼主 | 2018-8-3 10:56 | 只看该作者
//查找并检索用户协议
void Progress_UART4(void)
{
    UART4_Flag.Head_point=0XFF;
    //当前使用数组缓冲A
    if(UART4_Flag.Buf_Now==Buf_A)
    {
        //从B中检索数据
        UART4_Flag.Head_point=Cheack_FrameHead(UART4_Flag.Num_Rx,UART4_Flag.USER_USART_RX_Buf_B);
        /******在这里加入：校验数据帧的函数—开始*******/
        if(UART4_Flag.Head_point!=0XFF)//检索到了SIEW的位置
        {
            /******数据处理函数_START*******/
            UART4_Flag.SYS_STEP_UART=Crack_User_data(UART4_USARTx,UART4_Flag.USER_USART_RX_Buf_B,UART4_Flag.Head_point);
            /******数据处理函数_END*******/
        }
        //数据无效，进入IDLE模式
        if(UART4_Flag.Head_point==0XFF)
        {
            UART4_Flag.SYS_STEP_UART=Sys_IDLE;
        }
        /******在这里加入：校验数据帧的函数—结束*******/
    }
    //当前使用数组缓冲B
    if(UART4_Flag.Buf_Now==Buf_B)
    {
        //从B中检索数据
        UART4_Flag.Head_point=Cheack_FrameHead(UART4_Flag.Num_Rx,UART4_Flag.USER_USART_RX_Buf_A);
        /******在这里加入：校验数据帧的函数—开始*******/
        if(UART4_Flag.Head_point!=0XFF)//检索到了SIEW的位置
        {
            /******数据处理函数_START*******/
            UART4_Flag.SYS_STEP_UART=Crack_User_data(UART4_USARTx,UART4_Flag.USER_USART_RX_Buf_A,UART4_Flag.Head_point);
            /******数据处理函数_END*******/
        }
        //数据无效，进入IDLE模式
        if(UART4_Flag.Head_point==0XFF)
        {
            UART4_Flag.SYS_STEP_UART=Sys_IDLE;
        }
        /******在这里加入：校验数据帧的函数—结束*******/
    }
    //处理完成后，对接收的数据进行复位
    UART4_Flag.Num_Rx=0;
    //处理完成后，对位置的数据进行复位
    UART4_Flag.Head_point=0XFF;
}//END_void Copy_buf(void)

使用特权

评论回复 赏
38楼
東南博士|  楼主 | 2018-8-3 10:56 | 只看该作者
//查找并检索用户协议
void Progress_UART5(void)
{
    UART5_Flag.Head_point=0XFF;
    //当前使用数组缓冲A
    if(UART5_Flag.Buf_Now==Buf_A)
    {
        //从B中检索数据
        UART5_Flag.Head_point=Cheack_FrameHead(UART5_Flag.Num_Rx,UART5_Flag.USER_USART_RX_Buf_B);
        /******在这里加入：校验数据帧的函数—开始*******/
        if(UART5_Flag.Head_point!=0XFF)//检索到了SIEW的位置
        {
            /******数据处理函数_START*******/
            UART5_Flag.SYS_STEP_UART=Crack_User_data(UART5_USARTx,UART5_Flag.USER_USART_RX_Buf_B,UART5_Flag.Head_point);
            /******数据处理函数_END*******/
        }
        //数据无效，进入IDLE模式
        if(UART5_Flag.Head_point==0XFF)
        {
            UART5_Flag.SYS_STEP_UART=Sys_IDLE;
        }
        /******在这里加入：校验数据帧的函数—结束*******/
    }
    //当前使用数组缓冲B
    if(UART5_Flag.Buf_Now==Buf_B)
    {
        //从B中检索数据
        UART5_Flag.Head_point=Cheack_FrameHead(UART5_Flag.Num_Rx,UART5_Flag.USER_USART_RX_Buf_A);
        /******在这里加入：校验数据帧的函数—开始*******/
        if(UART5_Flag.Head_point!=0XFF)//检索到了SIEW的位置
        {
            /******数据处理函数_START*******/
            UART5_Flag.SYS_STEP_UART=Crack_User_data(UART5_USARTx,UART5_Flag.USER_USART_RX_Buf_A,UART5_Flag.Head_point);
            /******数据处理函数_END*******/
        }
        //数据无效，进入IDLE模式
        if(UART5_Flag.Head_point==0XFF)
        {
            UART5_Flag.SYS_STEP_UART=Sys_IDLE;
        }
        /******在这里加入：校验数据帧的函数—结束*******/
    }
    //处理完成后，对接收的数据进行复位
    UART5_Flag.Num_Rx=0;
    //处理完成后，对位置的数据进行复位
    UART5_Flag.Head_point=0XFF;
}//END_void Copy_buf(void)

使用特权

评论回复 赏
39楼
東南博士|  楼主 | 2018-8-3 10:57 | 只看该作者
//数据处理
void Date_Progress_Uart1(void)
{
    if(UART1_Flag.IDLE_FLAG==SET)//如果总线空闲中断
    {
        UART1_Flag.IDLE_FLAG=RESET;
        //查找并检索用户协议
        Progress_UART1();
    }
}

使用特权

评论回复 赏
40楼
東南博士|  楼主 | 2018-8-3 10:57 | 只看该作者
//数据处理
void Date_Progress_Uart2(void)
{
    if(UART2_Flag.IDLE_FLAG==SET)//如果总线空闲中断
    {
        UART2_Flag.IDLE_FLAG=RESET;
        //查找并检索用户协议
        Progress_UART2();
    }
}

使用特权

评论回复 赏
下一页 »
1234下一页
返回列表
发新帖 我要提问
高级模式
B Color Image Link Quote Code 收费 Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则