探索者开发版 W25Q128能读到正确ID 但是读写数据不正常

Nioclas1218

如题 例程是正常的 根据例程 把SPI改成了dma模式 然后读写就不正常 读出来都是0x00 没法确定是读不正常 还是写不正常 代码如下 有大佬能帮忙分析下可能的原因吗
测试的时候就是wrtie_page 在地址0x00写32个数据，然后read读地址0x00

1. SPI_HandleTypeDef hspi1;
   
2. DMA_HandleTypeDef hdma_spi1_rx;
   
3. DMA_HandleTypeDef hdma_spi1_tx;
   
4. 
   
5. static uint16_t W25QXX_ID = 0;
   
6. 
   
7. static uint8_t SPI2_ReadWriteOneByte(uint8_t data)
   
8. {
   
9.         uint8_t receive = 0;
   
10.        
    
11.         HAL_SPI_TransmitReceive_DMA(&hspi1, &data, &receive, 1);
    
12.        
    
13.         return receive;
    
14. }
    
15. 
    
16. static void W25QXX_Write_Enable(void)
    
17. {
    
18.         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET);
    
19.        
    
20.         SPI2_ReadWriteOneByte(W25X_WriteEnable);
    
21.        
    
22.         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_SET);
    
23. }
    
24. 
    
25. static void W25QXX_Write_Disable(void)
    
26. {
    
27.         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET);
    
28.        
    
29.         SPI2_ReadWriteOneByte(W25X_WriteDisable);
    
30.        
    
31.         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_SET);
    
32. }
    
33. 
    
34. static uint8_t W25QXX_Read_SR(uint8_t num)
    
35. {
    
36.         uint8_t res = 0, cmd = 0;
    
37.        
    
38.         switch(num)
    
39.         {
    
40.                 case 1:
    
41.                         cmd = W25X_ReadStatusReg1;
    
42.                 break;
    
43.                
    
44.                 case 2:
    
45.                         cmd = W25X_ReadStatusReg2;
    
46.                 break;
    
47.                
    
48.                 case 3:
    
49.                         cmd = W25X_ReadStatusReg3;
    
50.                 break;
    
51.                
    
52.                 default:
    
53.                         cmd = W25X_ReadStatusReg1;
    
54.                 break;
    
55.         }
    
56.        
    
57.         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET);
    
58.        
    
59.         SPI2_ReadWriteOneByte(cmd);
    
60.         res = SPI2_ReadWriteOneByte(0xff);
    
61.        
    
62.         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_SET);
    
63.        
    
64.         return res;
    
65. }
    
66. 
    
67. static void W25QXX_Write_SR(uint8_t num, uint8_t data)
    
68. {
    
69.         uint8_t cmd = 0;
    
70.        
    
71.         switch(num)
    
72.         {
    
73.                 case 1:
    
74.                         cmd = W25X_ReadStatusReg1;
    
75.                 break;
    
76.                
    
77.                 case 2:
    
78.                         cmd = W25X_ReadStatusReg2;
    
79.                 break;
    
80.                
    
81.                 case 3:
    
82.                         cmd = W25X_ReadStatusReg3;
    
83.                 break;
    
84.                
    
85.                 default:
    
86.                         cmd = W25X_ReadStatusReg1;
    
87.                 break;
    
88.         }       
    
89.        
    
90.         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET);
    
91.        
    
92.         SPI2_ReadWriteOneByte(cmd);
    
93.         SPI2_ReadWriteOneByte(data);
    
94.        
    
95.         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_SET);
    
96. }
    
97. 
    
98. static void W25QXX_Wait_Busy(void)
    
99. {
    
100.         while((W25QXX_Read_SR(1) & 0x01) == 0x01);
     
101. }
     
102. 
     
103. static uint16_t W25QXX_Read_ID(void)
     
104. {
     
105.         uint16_t res = 0;
     
106.        
     
107.         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET);
     
108.        
     
109.         SPI2_ReadWriteOneByte(W25X_ManufactDeviceID);
     
110.         SPI2_ReadWriteOneByte(0x00);
     
111.         SPI2_ReadWriteOneByte(0x00);
     
112.         SPI2_ReadWriteOneByte(0x00);
     
113.        
     
114.         res  |= SPI2_ReadWriteOneByte(0xff) << 8;
     
115.         res  |= SPI2_ReadWriteOneByte(0xff);
     
116.        
     
117.         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_SET);
     
118.        
     
119.         return res;
     
120. }
     
121. 
     
122. void W25QXX_Read(uint8_t *buffer, uint32_t addr, uint16_t byte)
     
123. {
     
124.         uint16_t i;
     
125.        
     
126.         rt_base_t level = 0;
     
127.        
     
128.         level = rt_hw_interrupt_disable();
     
129.        
     
130.         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET);
     
131.        
     
132.         SPI2_ReadWriteOneByte(W25X_ReadData);
     
133.        
     
134.         SPI2_ReadWriteOneByte((uint8_t)(addr >> 16));
     
135.         SPI2_ReadWriteOneByte((uint8_t)(addr >> 8));
     
136.         SPI2_ReadWriteOneByte((uint8_t)(addr));
     
137.        
     
138.         for(i = 0; i < byte; i++)
     
139.         {
     
140.                 buffer[i] = SPI2_ReadWriteOneByte(0xff);
     
141.         }
     
142.        
     
143.         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_SET);
     
144.        
     
145.         rt_hw_interrupt_enable(level);
     
146. }
     
147. 
     
148. void W25QXX_Write_Page(uint8_t *buffer, uint32_t addr, uint16_t byte)
     
149. {
     
150.         uint16_t i;
     
151. 
     
152.         rt_base_t level = 0;
     
153.        
     
154.         level = rt_hw_interrupt_disable();
     
155.        
     
156.         W25QXX_Write_Enable();
     
157.        
     
158.         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET);
     
159.        
     
160.         SPI2_ReadWriteOneByte(W25X_PageProgram);
     
161.        
     
162.         SPI2_ReadWriteOneByte((uint8_t)(addr >> 16));
     
163.         SPI2_ReadWriteOneByte((uint8_t)(addr >> 8));
     
164.         SPI2_ReadWriteOneByte((uint8_t)(addr));
     
165.        
     
166.         for(i = 0; i < byte; i++)
     
167.         {
     
168.                 SPI2_ReadWriteOneByte(buffer[i]);
     
169.         }
     
170.        
     
171.         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_SET);
     
172.        
     
173.         W25QXX_Wait_Busy();
     
174.        
     
175.         rt_hw_interrupt_enable(level);
     
176. }
     
177. 
     
178. void W25QXX_Init(void)
     
179. {
     
180.   __HAL_RCC_DMA2_CLK_ENABLE();
     
181. 
     
182.         HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 1, 0);
     
183.   HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);
     
184. 
     
185.   HAL_NVIC_SetPriority(DMA2_Stream3_IRQn, 1, 0);
     
186.   HAL_NVIC_EnableIRQ(DMA2_Stream3_IRQn);
     
187. 
     
188.   hspi1.Instance                                                                                                         = SPI1;
     
189.   hspi1.Init.Mode                                                                                                 = SPI_MODE_MASTER;
     
190.   hspi1.Init.Direction                                                                                 = SPI_DIRECTION_2LINES;
     
191.   hspi1.Init.DataSize                                                                                 = SPI_DATASIZE_8BIT;
     
192.   hspi1.Init.CLKPolarity                                                                         = SPI_POLARITY_LOW;
     
193.   hspi1.Init.CLKPhase                                                                                 = SPI_PHASE_1EDGE;
     
194.   hspi1.Init.NSS                                                                                                         = SPI_NSS_SOFT;
     
195.   hspi1.Init.BaudRatePrescaler                                                 = SPI_BAUDRATEPRESCALER_16;
     
196.   hspi1.Init.FirstBit                                                                                 = SPI_FIRSTBIT_MSB;
     
197.   hspi1.Init.TIMode                                                                                         = SPI_TIMODE_DISABLE;
     
198.   hspi1.Init.CRCCalculation                                                         = SPI_CRCCALCULATION_DISABLE;
     
199.   hspi1.Init.CRCPolynomial                                                                 = 10;
     
200.        
     
201.   if (HAL_SPI_Init(&hspi1) != HAL_OK)
     
202.   {
     
203.     Error_Handler();
     
204.   }
     
205.        
     
206.         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_SET);
     
207. 
     
208.         uint8_t mode = 0;
     
209.        
     
210.         W25QXX_ID = W25QXX_Read_ID();
     
211.         if(W25QXX_ID == W25Q256)
     
212.         {
     
213.                 mode = W25QXX_Read_SR(3);
     
214.                 if((mode & 0x01) == 0)
     
215.                 {
     
216.                         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET);
     
217.                        
     
218.                         SPI2_ReadWriteOneByte(W25X_Enable4ByteAddr);
     
219.                        
     
220.                         HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_SET);
     
221.                 }
     
222.         }
     
223.        
     
224.         printf("the ID is %x\r\n", W25QXX_ID);
     
225. }

复制代码

zxm3916

你光想读写，不擦除页，写个毛呀。

Nioclas1218

zxm3916 发表于 2021-4-15 20:33
你光想读写，不擦除页，写个毛呀。

忘了忘了....