OpenEdv-开源电子网

 找回密码
 立即注册
正点原子全套STM32/Linux/FPGA开发资料,上千讲STM32视频教程免费下载...
查看: 4174|回复: 5

LCD通过串口显示字符几次后会多一个字符

[复制链接]

34

主题

174

帖子

0

精华

金牌会员

Rank: 6Rank: 6

积分
1103
金钱
1103
注册时间
2017-3-10
在线时间
173 小时
发表于 2017-4-19 21:40:37 | 显示全部楼层 |阅读模式
1金钱
LCD通过串口显示字符几次后会多一个字符如输入AB的16进制ASC码几次后显示ABi,而且程序还死了。是怎么回事呢,原子哥

最佳答案

查看完整内容[请看2#楼]

如果是这样的问题怎么办呢? 数组我开的60的,我是没有去清空它,但每次接收了串口数据,前一个数据会被覆盖的吧。应该就不是溢出。
正点原子逻辑分析仪DL16劲爆上市
回复

使用道具 举报

34

主题

174

帖子

0

精华

金牌会员

Rank: 6Rank: 6

积分
1103
金钱
1103
注册时间
2017-3-10
在线时间
173 小时
 楼主| 发表于 2017-4-19 21:40:38 | 显示全部楼层
操作系统 发表于 2017-4-20 11:57
多半是数组下标溢出.造成的程序跑飞. 可以仿真跟踪.

如果是这样的问题怎么办呢?
数组我开的60的,我是没有去清空它,但每次接收了串口数据,前一个数据会被覆盖的吧。应该就不是溢出。
回复

使用道具 举报

50

主题

1805

帖子

0

精华

论坛元老

Rank: 8Rank: 8

积分
6662
金钱
6662
注册时间
2016-5-29
在线时间
910 小时
发表于 2017-4-20 11:57:43 | 显示全部楼层
多半是数组下标溢出.造成的程序跑飞. 可以仿真跟踪.
回复

使用道具 举报

14

主题

171

帖子

0

精华

中级会员

Rank: 3Rank: 3

积分
450
金钱
450
注册时间
2017-3-31
在线时间
118 小时
发表于 2017-4-20 15:31:42 | 显示全部楼层
stm32wwxf 发表于 2017-4-20 13:34
如果是这样的问题怎么办呢?
数组我开的60的,我是没有去清空它,但每次接收了串口数据,前一个数据会被 ...

意思是你的数组有60那么长,可是你下标读到60,那就溢出了
回复

使用道具 举报

50

主题

1805

帖子

0

精华

论坛元老

Rank: 8Rank: 8

积分
6662
金钱
6662
注册时间
2016-5-29
在线时间
910 小时
发表于 2017-4-20 21:43:26 | 显示全部楼层
串口接口数据他是不会自动完成你想要的功能.你的串口中断服务函数可以贴出来给大家看一下吗?
回复

使用道具 举报

34

主题

174

帖子

0

精华

金牌会员

Rank: 6Rank: 6

积分
1103
金钱
1103
注册时间
2017-3-10
在线时间
173 小时
 楼主| 发表于 2017-4-24 00:50:22 | 显示全部楼层
操作系统 发表于 2017-4-20 21:43
串口接口数据他是不会自动完成你想要的功能.你的串口中断服务函数可以贴出来给大家看一下吗?

[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[60];    //接收缓冲,最大64个字节u8 usart_rx_buf[60];
        u8 usart_rx_temporary[60]; //数据保存暂存器,最多能够缓存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=0xff;   //命令码
        u8 order=0x04;
        u8 check_temp=0;                //校验和
        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|RCC_APB2Periph_AFIO, 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);                                                                 //初始化串口
                        USART_Cmd(USART1, ENABLE);                                                                    //使能串口
                        //CPU的小缺陷:串口配置好,如果直接Send,则第1个字节发送不出去  
                        //如下语句解决第1个字节无法正确发送出去的问题   
                        USART_ClearFlag(USART1, USART_FLAG_TC);     //清发送外城标志,Transmission Complete flag
                       
                        NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
                        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0 ;        //抢占优先级0
                        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;                                //子优先级0
                        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 res;
                        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;                                                                                                                        //说明这是命令头,启动接收数据标志,进入数据接收阶段
                                                usart_rd_lentemp=0;
                                                check_temp=0;
                                        }
                                       
                                        if(usart_rx_enableflag==1)                                                                                                                //到接受数据标志置位时,接受数据
                                                {                                                                       
                                                        if(usart_rd_lentemp==0)
                                                                        {
                                                                        }
                                                        else if(usart_rd_lentemp==1)                                                                                                                //命令头后第一个数据为需要传输的数据的长度
                                                                {
                                                                        usart_rd_len=res;                                                                                //读取数据的长度

                                                                        if(usart_rd_len==68)                                                                //当第二位为68时
                                                                        {
                                                                                usart_rx_lenrightflag=0;                                                                                //数据校验和正确标志清零
                                                                                usart_rx_successflag=0;                                                                                        //数据接收成功标志清零
                                                                                usart_rx_enableflag=1;                                                                                        //数据接收完成,数据接收启动标志清零
                                                                                usart_rd_len=0;                                                                                                                        //数据长度清零
                                                                                usart_rd_lentemp=0;                                                                                                        //数据长度暂存器清零                                                                                                                                                               
                                                                        }
                                                                        else 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==2)                                        //命令头后第2个数据为命令码
                                                        {
                                                                order=res;
                                                                if(order!=0x00&&order!=0x01&&order!=0x02)
                                                                {
                                                                                order=0xff;                                                                                                                        //清除命令码
                                                                                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_len+2个数据时,校验和相等不
                                                                {               
                                                                        if(res==(check_temp+order))                                                                                                                //当数据校验和正确时
                                                                                usart_rx_lenrightflag=1;                                                                                //数据校验和正确标志置一
                                                                        else                                                                                                                                                                        
                                                                        {                                                                                                                                                                                        //当数据校验和校验错误时
                                                                                order=0xff;                                                                                                                                        //清除命令码                                                                               
                                                                                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_len+3个数据时,校验包尾是否正确
                                                                {
                                                                        if((res==0x16)&&(usart_rx_lenrightflag==1))                //如果包尾数据与校验和都正确
                                                                        {
//                                                                                usart_cmd=order;
                                                                                usart_rx_lenrightflag=0;                                                                                //数据校验和正确标志清零
                                                                                usart_rx_successflag=1;                                                                                        //数据接收成功标志置一
                                                                                usart_rx_enableflag=0;                                                                                        //数据接收完成,数据接收启动标志清零
//                                                                                usart_rd_len=seri_count;                                                                                                        //数据长度清零
                                                                                usart_rd_lentemp=0;                                                                                                 //数据长度暂存器清零                                                                               
                                                                        }
                                                                        else
                                                                        {                                                                                                                                                                                        //当包尾数据校验错误时
                                                                                order=0xff;                                                                                                                                //清除命令码                               
                                                                                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_SendData(USART1,check_temp);
                                                                usart_rx_temporary[usart_rd_lentemp-3]=res;        //当usart_rd_lentemp为数据段时,将数据存到串口数据接收寄存器中
                                                        }
                                                usart_rd_lentemp++;                                                                                                                                        //每次记录数据,数据长度暂存器自加       
                                                if(usart_rx_successflag==1)                                                                                                        //如果成功接收到信息数据,将缓存usart_rx_temporary[]内的数据传递给usart_rx_buf[][]
                                                        {
//                                                                USART_SendData(USART1,usart_rd_len);
                                                                for(i=0;i<usart_rd_len-1;i++)
                                                                        {
                                                                                usart_rx_buf=usart_rx_temporary;
//                                                                                USART_SendData(USART1,usart_rx_buf);
                                                                        }//考虑buf没清空的问题 exp
                                                                        usart_rx_successflag=0;
                                                                        usart_cmd=order;
//                                                                        usart_rd_len=0;                                                                                                                        //数据长度清零
                                                        }                       
                                        }
                         }
}
               
               
               
               
               
                [/mw_shl_code]
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则



关闭

原子哥极力推荐上一条 /2 下一条

正点原子公众号

QQ|手机版|OpenEdv-开源电子网 ( 粤ICP备12000418号-1 )

GMT+8, 2025-8-21 22:53

Powered by OpenEdv-开源电子网

© 2001-2030 OpenEdv-开源电子网

快速回复 返回顶部 返回列表