串口收发没问题,但是串口输入命令LCD上没反应,应该没把数据存入特定的变量里,你们看看程序有问题没,谢谢大家

2019-08-22 14:52发布

[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]

友情提示: 此问题已得到解决,问题已经关闭,关闭后问题禁止继续编辑,回答。
该问题目前已经被作者或者管理员关闭, 无法添加新回复
2条回答
stm32wwxf
1楼-- · 2019-08-22 18:31
stm32wwxf 发表于 2017-4-10 15:39
[mw_shl_code=applescript,true]
#include "stm32f10x.h"
#include "LCD_RA8875.h"

这个是主函数,上面的是串口的函数。

补充内容 (2017-5-24 09:18):
最后检查出来,程序的问题,时序配置,引脚配置
stm32wwxf
2楼-- · 2019-08-22 23:02
[mw_shl_code=applescript,true]
#include "stm32f10x.h"
#include "LCD_RA8875.h"
#include "bsp_tft_lcd.h"
#include "fonts.h"
#include "usart.h"

extern  unsigned char gImage_11[];//19206

//配置系统时钟,使能各外设时钟
void RCC_Configuration(void)
{
        ErrorStatus HSEStartUpStatus;                           //定义枚举类型变量HSEStartUpStatus
        RCC_DeInit();                                           //复位系统时钟
        RCC_HSEConfig(RCC_HSE_ON);                              //开启HSE
        HSEStartUpStatus = RCC_WaitForHSEStartUp();             //等待HSE起振
        if(HSEStartUpStatus == SUCCESS)
        {
                FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
                FLASH_SetLatency(FLASH_Latency_2);
                RCC_HCLKConfig(RCC_SYSCLK_Div1);                      //选择HCLK时钟源为SYSCLK1分频
                RCC_PCLK2Config(RCC_HCLK_Div1);                       //选择PCLK2的时钟源为HCLK1分频
                RCC_PCLK1Config(RCC_HCLK_Div2);                       //选择PCLK1的时钟源为HCLK2分频
                RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);        //选择PLL时钟源为HSE1分频,9倍频
                RCC_PLLCmd(ENABLE);                                   //使能PLL
                while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);   //等待PLL输出稳定
                RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);            //系统时钟为PLL
                while(RCC_GetSYSCLKSource() != 0x08);                 //等待PLL为系统时钟源
        }
//        RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC
//                           |RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOE
//                           , ENABLE );
}

void Delay(uint32_t Time)
{
    uint32_t i;
   
    i = 0;
    while (Time--)
                {
       for (i = 0; i < 8000; i++);
    }
}
/*****************************************************************************
**   Main Function  main()
******************************************************************************/
int main(void)
{
        //char data[60]={'0x33','0x34','0x61'};
        FONT_T tFont;                                                      //定义一个字体结构体变量,用于设置字体参数
        tFont.usFontCode = FC_ST_16;                          //字体代码 16点阵
        tFont.usTextColor = RED;                              // 字体颜 {MOD}
        tFont.usBackColor =        WHITE;                              //文字背景颜 {MOD}
        tFont.usSpace = 0;                                                      //文字间距,单位 = 像素
        RCC_Configuration();                                  //系统时钟配置
        LCD_InitHard();
        uart_init(115200);
//        RA8875_DispAscii(6,6,"welcome");
//        printf(a,"%64x",USART_RX_BUF);
        RA8875_Clear(WHITE);                                  //清屏
        Delay(1000);
        RA8875_SetFrontColor(RED);
       
                /*此段显示来自8875内部内建8x16 点的ASCII 字型*/
//        RA8875_DispAscii(0, 0, "System startup,please wait...");
while(1)
        {
//                USART_SendData(USART1, 0x41);   
//      Delay(3000);  
                if(usart_cmd==0x00)
                        {
                                        RA8875_Clear(RED);
                                        Delay(1000);
                        }
                else if(usart_cmd==0x01)
                        {
                                RA8875_DispAscii(0,0,"System startup,please wait...");
                        }
                else if(usart_cmd==0x02)
                {
                }
        }
               
//                 tFont.usTextColor = RED;
//                 RA8875_DispString(320, 292, "显示测试WB-RA8875 34455sdfgsehrt", &tFont);

//                /*以下绘图功能由RA8875完成,无需额外的软件图形算法*/
//               
//                 RA8875_FillRect(10, 100, 50, 100, RED);                //矩形填充
//       
//                 RA8875_DrawLine(140 , 150 , 180 , 100 , MAGENTA);      //画线
//               
//                 RA8875_DrawRect(10,200, 50, 100, BLUE);                //画矩形

//                 RA8875_DrawCircle(360,100,80, GREEN);                  //画圆

//                 RA8875_FillCircle(400, 100, 80, BLUE);                 //蓝 {MOD}圆形填充

//                 RA8875_FillCircle(440, 100, 80, RED);

//                 RA8875_DrawBMP(630, 60, 97, 99,(uint16_t*)gImage_11);   //图片显示
//                 Delay(500);
}

/*------------------------------*/
//                RA8875_PutPixel(8,8,RED);
//                RA8875_SetBackColor(RED);//设定背景 {MOD}NO
//                RA8875_SetFrontColor(RED);//设定前景 {MOD}NO
//                RA8875_FillRect(0,0,200,400,WHITE);//画矩形填充颜 {MOD}:OK
//                        RA8875_DrawRect(0,0,480,800,WHITE);
//                RA8875_DrawVLine(0,0,16,RED);//画一条线
//                RA8875_DispAscii(0,0,);
               
//          RA8875_Clear(RED);
//          Delay(1000);
//                RA8875_Clear(GREEN);
//          Delay(1000);
//                RA8875_Clear(BLUE);
//          Delay(1000);
//                RA8875_Clear(YELLOW);
//          Delay(1000);
//                RA8875_Clear(GREY);
//          Delay(1000);
//                RA8875_Clear(MAGENTA);
//          Delay(1000);
//                RA8875_Clear(CYAN);
//          Delay(1000);


/*----------------------OK-------------------------*/
//        RA8875_FillRect(0,0,480,800,WHITE);//画矩形填充颜 {MOD}:OK
//          RA8875_Clear(RED);
//          Delay(1000);


/*---------------------有问题----------------------*/
//        RA8875_DrawLine(0,0,200,300,RED);//在两点之间画线

/////////////////////////////////
//                if(USART_RX_STA[0]=0x68)                //如果已经接收到超过字符串长度的字符
//          {  
//                u8 length;
//                u8 i=0;
//                USART_RX_STA[1]= length ;        //找字头
//                                for(x=0;x<Data_Length-1;x++)     //将校验和之前的字符串相加
//                                                    {
//                                                                        sum_check=sum_check+USART_RX_BUF[x];
//                                                                }
//                                if(sum_check==USART_RX_BUF[Data_Length-1])   //判断校验和
//                                        {
//                                                seri_count=0;   //为下一次进中断做好准备
//                                                sum_check=0;    //校验和清零,准备下一次校验
//                                        }
//                                }
//                        }
[/mw_shl_code]

一周热门 更多>