关于STM32接收数组问题（发送abcde接收{e,0,0,0,0}）

jungege

程序功能就是单片机接收上位机（串口助手）发送的 adbcd ；将接收的数据放入数组 Rec_array[] ；
通过 if(0 == memcmp(Rec_array, "abc", 3)) 语句，翻转 LED ;

正常情况是数组存放了 {a,b,c,d,e}; 前三项 abc对应正确，led翻转

但是接收数据，在 if(0 == memcmp(Rec_array, "abc", 3)) 识别时数组里只存放了 {b,0,0,0,0};
想做到 发送-abcde-五位，led翻转，再发送-aaaaa-不翻转，再发送-abcee-翻转


程序结构很简单：一个usart函数，一个mian函数usart.c文件：


附件：
USART-STRING.rar (275.31 KB, 下载次数: 3)

2021-9-22 17:04 上传

点击文件名下载附件

1. #include "usart.h"
   
2. #include "string.h"
   
3. #include "led.h"
   
4. 
   
5. #define Code_Max 5
   
6. u8 Rec_array[Code_Max];
   
7. unsigned int Code_Cnt = 0;
   
8. 
   
9. /*中断初始化*/
   
10. static void USART1_NVIC_Configuration(void)
    
11. {
    
12.         NVIC_InitTypeDef NVIC_InitStructure;
    
13.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
    
14.         NVIC_InitStructure.NVIC_IRQChannel = USART_IRQ;
    
15.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    
16.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
    
17.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
18.        
    
19.         NVIC_Init(&NVIC_InitStructure);
    
20. }
    
21. void USART1_GPIO_Configuration(void)
    
22. {
    
23.         GPIO_InitTypeDef GPIO_InitStructure;
    
24.         /*开启串口GPIO时钟*/       
    
25.         USART_APBxClkCmd(USART_GPIO_CLK,ENABLE);       
    
26.         GPIO_InitStructure.GPIO_Pin = USART_TX_GPIO_PIN;
    
27.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    
28.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
29.         GPIO_Init(USART_TX_GPIO_PORT,&GPIO_InitStructure);
    
30.         GPIO_InitStructure.GPIO_Pin = USART_RX_GPIO_PIN;
    
31.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
32.         GPIO_Init(USART_RX_GPIO_PORT,&GPIO_InitStructure);
    
33. }
    
34. /*串口GPIO初始化*/
    
35. void USART1_Configuration(void)
    
36. {       
    
37.         USART1_NVIC_Configuration();
    
38.         USART1_GPIO_Configuration();
    
39.         USART_InitTypeDef USART_InitStructure;
    
40.         /*开启串口时钟*/
    
41.         USART_APBxClkCmd(USART_CLK,ENABLE);
    
42.         USART_InitStructure.USART_BaudRate = USART_Baudrate;
    
43.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    
44.         USART_InitStructure.USART_StopBits = USART_StopBits_1;
    
45.         USART_InitStructure.USART_Parity = USART_Parity_No;
    
46.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
47.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
48.         USART_Init(USARTx,&USART_InitStructure);
    
49.        
    
50.         USART_ITConfig(USARTx,USART_IT_RXNE,ENABLE);
    
51.         USART_ITConfig(USARTx,USART_IT_TXE,DISABLE);
    
52.        
    
53.         USART_Cmd(USARTx,ENABLE);
    
54. }
    
55. /*串口接收中断*/
    
56. void USART1_IRQHandler(void)
    
57. {
    
58.         u8 data;
    
59.         if(USART_GetITStatus(USARTx,USART_IT_RXNE) != RESET)
    
60.         {
    
61.                 data = USART_ReceiveData(USARTx);
    
62.                 Rec_array[Code_Cnt] = data;//存放到数组
    
63.                 Code_Cnt++;
    
64.                 if(Code_Cnt >= Code_Max)
    
65.                 {        Code_Cnt = 0;
    
66.                 }
    
67.     USART_ClearITPendingBit(USARTx, USART_IT_RXNE);
    
68.         }
    
69. }
    
70. /*串口接收数据函数*/
    
71. void USART1_Recive(void)
    
72. {
    
73.         Code_Cnt = 0;
    
74.         if(0 == memcmp(Rec_array, "abc", 3))
    
75.         {
    
76.                 LED_BLUE;
    
77.         }
    
78.         if(0 == memcmp(Rec_array, "bca", 3))
    
79.         {
    
80.                 LED_RED;
    
81.         }
    
82.         Rec_array[0] = Rec_array[1] = Rec_array[2] = Rec_array[3] = Rec_array[4] = 0;
    
83. }
    
84. 
    

复制代码

usart.h文件

1. #ifndef __USART_H
   
2. #define        __USART_H
   
3. 
   
4. #include "stm32f10x.h"
   
5. #include <stdio.h>
   
6. 
   
7. #define USARTx                       USART1
   
8. #define USART_CLK                    RCC_APB2Periph_USART1
   
9. #define USART_Baudrate               115200
   
10. 
    
11. #define        USART_GPIO_CLK                                RCC_APB2Periph_GPIOA
    
12. #define USART_APBxClkCmd                        RCC_APB2PeriphClockCmd
    
13. 
    
14. #define USART_TX_GPIO_PORT                GPIOA
    
15. #define USART_TX_GPIO_PIN                        GPIO_Pin_9
    
16. #define USART_RX_GPIO_PORT                GPIOA
    
17. #define USART_RX_GPIO_PIN                        GPIO_Pin_10
    
18. 
    
19. #define USART_IRQ                                                        USART1_IRQn
    
20. #define USART_IRQHandler                        USART1_IRQHandler
    
21. 
    
22. void USART1_Configuration(void);
    
23. void USART1_Recive(void);
    
24. 
    
25. #endif
    

复制代码

main.c主函数

1. #include "stm32f10x.h"
   
2. #include "led.h"
   
3. #include "usart.h"
   
4. 
   
5. int main(void)
   
6. {       
   
7.         LED_GPIO_Config();
   
8.         USART1_Configuration();
   
9.         while (1)
   
10.         {
    
11.                 USART1_Recive();
    
12.         }
    
13. }
    
14. 
    

复制代码

我没钱了呀

和谐年份

数组接收 更新是不是不正确？

jungege

和谐年份 发表于 2021-9-23 10:02
数组接收 更新是不是不正确？

1. /*串口接收中断*/
   
2. void USART1_IRQHandler(void)
   
3. {
   
4.         u8 data;
   
5.         if(USART_GetITStatus(USARTx,USART_IT_RXNE) != RESET)
   
6.         {
   
7.                 data = USART_ReceiveData(USARTx);
   
8.                 Rec_array[Code_Cnt] = data;
   
9.                 Code_Cnt++;
   
10.                 if(Code_Cnt >= Code_Max)
    
11.                 {        Code_Cnt = 0;
    
12.                 }
    
13.     USART_ClearITPendingBit(USARTx, USART_IT_RXNE);
    
14.         }
    
15. }
    
16. /*串口接收数据函数*/
    
17. void USART1_Recive(void)
    
18. {
    
19.         Code_Cnt = 0;
    
20.         if(0 == memcmp(Rec_array, "123", 3))
    
21.         {
    
22.                 LED_BLUE;
    
23.         }
    
24.         if(0 == memcmp(Rec_array, "321", 3))
    
25.         {
    
26.                 LED_RED;
    
27.         }
    
28.         Rec_array[0] = Rec_array[1] = Rec_array[2] = Rec_array[3] = Rec_array[4] = 0;
    
29. }
    

复制代码

不知道你表达什么，上是数组的中断接收以及处理程序
下是定义的参数

1. #define Code_Max 5 //最大值
   
2. u8 Rec_array[Code_Max];//数组
   
3. unsigned int Code_Cnt = 0;//数组的第几位

复制代码

pdwdzz

你while里一直清0  Code_Cnt,肯定存不到数据啊。

jungege

pdwdzz 发表于 2021-9-23 17:05
你while里一直清0  Code_Cnt,肯定存不到数据啊。

但是我这边有一份代码也是有这个语句，他却能完整接收程序并判断，否则的话，最后 。清零语句应该放在哪呢

Monsteri

串口中断里边已经有清零了，接收函数里边不需要在清零

jungege

Monsteri 发表于 2021-9-24 13:56
串口中断里边已经有清零了，接收函数里边不需要在清零

1. void USART1_Recive(void)
   
2. {
   
3.     Usart1_ReceLen = 0;
   
4. 
   
5.     if(0 == memcmp(ReceBuff1, "<0>", 3))
   
6.     {
   
7.         Close_OG = 0;
   
8.     }
   
9. 
   
10.     if(0 == memcmp(ReceBuff1, "<1>", 3))
    
11.     {
    
12.         Close_OG = 1;
    
13.     }
    
14.     if(0 == memcmp(ReceBuff1, "[?]", 3))
    
15.     {
    
16.         USART1_Send("page3.n0.val=", Rounding_result_lx);
    
17.     }
    
18.     if(0 == memcmp(ReceBuff1, ":01;", 4))
    
19.     {
    
20.         Send_Act("Part1");
    
21.         Start_Part1 = 1;
    
22.         Start_Part2 = Start_Part12 = 0;
    
23.     }
    
24.     if(0 == memcmp(ReceBuff1, ":10;", 4))
    
25.     {
    
26.         Start_Part2 = 1;
    
27.         Start_Part1 = Start_Part12 = 0;
    
28.     }
    
29.     if(0 == memcmp(ReceBuff1, ":11;", 4))
    
30.     {
    
31.         Send_Act("Part1+Part2");
    
32.         Start_Part12 = 1;
    
33.         Start_Part1 = Start_Part2 = 0;
    
34.     }
    
35.     if(0 == memcmp(ReceBuff1, ":AA;", 4))
    
36.     {
    
37.         if(!SENSOR4)
    
38.         {
    
39.             FASTEN_DOWN = 0; //???°????
    
40.             FASTEN_UP = 1; //???°???????
    
41.         }
    
42.     }
    
43.     if(0 == memcmp(ReceBuff1, ":BB;", 4))
    
44.     {
    
45.         if(!SENSOR0)
    
46.         {
    
47.             USB_ACT = 0;//USB插入
    
48.         }
    
49.     }
    
50.     if(0 == memcmp(ReceBuff1, ":CC;", 4))
    
51.     {
    
52.         if(!SENSOR6)
    
53.         {
    
54.             PRESS_DOWN = 0; //????????
    
55.             PRESS_UP = 1; //???????????
    
56.             Twinkle = 1;
    
57.         }
    
58.     }
    
59.     if(0 == memcmp(ReceBuff1, ":DD;", 4))
    
60.     {
    
61.         CLICK_ACT = 0; //?????
    
62.     }
    
63.     if(0 == memcmp(ReceBuff1, ":EE;", 4))
    
64.     {
    
65.         if(!SENSOR9)
    
66.         {
    
67.             SHOCK_ACT = 0; //?????
    
68.         }
    
69.     }
    
70.     if(0 == memcmp(ReceBuff1, ":aa;", 4))
    
71.     {
    
72.         FASTEN_DOWN = 1; //???°???????
    
73.         FASTEN_UP = 0; //???°????
    
74.     }
    
75.     if(0 == memcmp(ReceBuff1, ":bb;", 4))
    
76.     {
    
77.         USB_ACT = 1;//USB拔出
    
78.     }
    
79.     if(0 == memcmp(ReceBuff1, ":cc;", 4))
    
80.     {
    
81.         PRESS_DOWN = 1; //???????????
    
82.         PRESS_UP = 0; //????????
    
83.     }
    
84.     if(0 == memcmp(ReceBuff1, ":dd;", 4))
    
85.     {
    
86.         CLICK_ACT = 1; //?????
    
87.     }
    
88.     if(0 == memcmp(ReceBuff1, ":ee;", 4))
    
89.     {
    
90.         SHOCK_ACT = 1; //?????
    
91.     }
    
92.     if(0 == memcmp(ReceBuff1, "Reset", 5))
    
93.     {
    
94.         Reset_Part = 1;
    
95.     }
    
96.     if(0 == memcmp(ReceBuff1, "Stop", 4))
    
97.     {
    
98.         Stop_Part = 1;
    
99.     }
    
100.     ReceBuff1[0] = ReceBuff1[1] = ReceBuff1[2] = ReceBuff1[3] = ReceBuff1[4] = 0;
     
101. }

复制代码

为什么这就可以填写清零语句，也是放到while(1)一直执行
参数只是名称不一样，性质与位置都一样
前面的定义

1. #define USART1_REC_LEN       5
   
2. 
   
3. u8  ReceBuff1[USART1_REC_LEN];
   
4. 
   
5. unsigned int Usart1_ReceLen;

复制代码

jungege

其实你们的建议我采纳过，但是不仅要发第一次可以，要稳定一直可以，即使过程中发错几次数据，也可以下一次正常发送接收，反应
能不能有调试好的程序

程功之道

jungege 发表于 2021-9-24 14:14
其实你们的建议我采纳过，但是不仅要发第一次可以，要稳定一直可以，即使过程中发错几次数据，也可以下一次 ...

建议仿真找问题，看数组，看数组坐标寄存器，这个问题一仿真就出来了

FourReal

用的哪个芯片，我可以发你一份串口+DMA控制的程序

pdwdzz

jungege 发表于 2021-9-24 11:20
但是我这边有一份代码也是有这个语句，他却能完整接收程序并判断，否则的话，最后 。清零语句应该放在哪 ...

那肯定是和你写的有不同之处的，不可能主函数一直清除计数还能接收到数组里。

jungege

pdwdzz 发表于 2021-9-24 16:31
那肯定是和你写的有不同之处的，不可能主函数一直清除计数还能接收到数组里。

并没有不同之处，唯一不同之处就是他处理的if很多罢了，上位机发送stop，它也确实接收到了stop，但我的就不行。关于串口中断这方面可以说是一模一样，所以就很纳闷

jungege

FourReal 发表于 2021-9-24 16:07
用的哪个芯片，我可以发你一份串口+DMA控制的程序

目前看样子不能能仿照程序一样了，它的接收处理函数放在while一直循环（里面包含清零操作），我的程序做不到。
程序初衷是和源程序一样的：接收上位机指令，并存放数组中，在主函数whlie中用memcmp来判断处理。
之前程序写的跟源码一模一样性质，但现在改动如下（实现了我持续发送指令的操作以及接收错误指令后重新正常接收处理）
在串口中断语句

1. void USART1_IRQHandler(void)

复制代码

，以及接收后处理语句

1. void USART1_Recive(void)
   

复制代码

麻烦是麻烦了点，但实现我想要的功能
正常发送一次指令，五位，；作为结束位
如 abcd；

工程文件如下：

1. https://jun7033.lanzouw.com/itzGhuh364f
   
2. //密码:jun

复制代码

jungege

pdwdzz 发表于 2021-9-24 16:31
那肯定是和你写的有不同之处的，不可能主函数一直清除计数还能接收到数组里。

确实，你的说法放在我这里是这样，但是针对于源程序我的疑问跟你一样，他为什么清零了还可以判断，除非中断接收是一次性都接受完发送的  stop 指令，然后才进入while（1）里面。但他确确实实完整接收到了stop 。
目前情况是我的接收过程中经过了while里面的清零语句
而源码接收过程中没有经过while清零语句，程序如上

xuyaqi

我改了一下，试下这个工程。 USART-STRING改.rar (4.24 MB, 下载次数: 8)

2021-9-25 15:56 上传

点击文件名下载附件