1. <div class="blockcode"><blockquote>#include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   
4. 
   
5. #define SPI1_CS_Pin GPIO_PIN_4
   
6. 
   
7. void Delay(__IO uint32_t nCount);
   
8. 
   
9. void Delay(__IO uint32_t nCount)
   
10. {
    
11. while(nCount--){}
    
12. }
    
13. 
    
14. int main(void)
    
15. {
    
16.     uint16_t GetData=0;
    
17.     uint16_t Temperature = 0;
    
18.     uint16_t T = 0;
    
19. 
    
20. 
    
21. 
    
22.     GPIO_InitTypeDef GPIO_A;        //定义一个GPIO_InitTypeDef的结构体GPIO_A
    
23.     SPI_HandleTypeDef hspi1;        //SPI句柄
    
24. 
    
25. 
    
26.     HAL_Init(); //初始化HAL库
    
27.     Stm32_Clock_Init(360,25,2,8); uart_init(115200); //初始化USART
    
28. 
    
29.     __HAL_RCC_SPI1_CLK_ENABLE();        //开启SP1时钟
    
30.     __HAL_RCC_USART1_CLK_ENABLE();
    
31.     __HAL_RCC_GPIOA_CLK_ENABLE(); //开启GPIOA时钟
    
32. 
    
33.     GPIO_A.Pin = GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7;
    
34.     GPIO_A.Mode = GPIO_MODE_AF_PP;        //复用推挽输出
    
35.     GPIO_A.Pull=GPIO_PULLUP; //上拉
    
36.     GPIO_A.Speed = GPIO_SPEED_FAST; //2MHz
    
37.     GPIO_A.Alternate = GPIO_AF5_SPI1;
    
38.     HAL_GPIO_Init(GPIOA,&GPIO_A);        //上面为配置参数，此处启动初始化
    
39. 
    
40.     GPIO_A.Pin=SPI1_CS_Pin; //配置PA4（CS片选信号）
    
41.     GPIO_A.Mode=GPIO_MODE_OUTPUT_PP; //推挽输出
    
42.     GPIO_A.Speed = GPIO_SPEED_FAST; //2MHz
    
43.     HAL_GPIO_Init(GPIOA,&GPIO_A);        //上面为配置参数，此处启动初始化
    
44.     HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4,GPIO_PIN_SET);        // 先把片选拉高，真正用的时候再拉低
    
45. 
    
46.     hspi1.Instance = SPI1;
    
47.     hspi1.Init.Mode = SPI_MODE_MASTER;        //主模式
    
48.     hspi1.Init.Direction = SPI_DIRECTION_2LINES_RXONLY;//SPI设置为单线接受
    
49.     hspi1.Init.DataSize = SPI_DATASIZE_16BIT;//SPI发送接收数据为16位帧格式
    
50.     hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;//同步时钟空闲状态为 di电平
    
51.     hspi1.Init.CLKPhase = SPI_PHASE_2EDGE;        //同步时钟第一个跳变沿数据被采集        
    
52.     hspi1.Init.NSS = SPI_NSS_SOFT;        //NSS信号由软件控制
    
53.     hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256; //波特率预分频值为256；
    
54.     hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;        //数据传输从MSB位开始
    
55.     hspi1.Init.TIMode = SPI_TIMODE_DISABLE;        //关闭TI模式
    
56.     hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;        //关闭CRC
    
57.     hspi1.Init.CRCPolynomial = 7;        //CRC值计算的多项式
    
58.     HAL_SPI_Init(&hspi1);        //初始化
    
59.     __HAL_SPI_ENABLE(&hspi1);        //使能SPI1
    
60. 
    
61.     #define SPI1_L HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);//片选信号拉低为SPI_L
    
62.     #define SPI1_H HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);        //片选信号拉高为SPI_H
    
63.     SPI1_H;        //拉高片选，为后面开启片选做准备
    
64. 
    
65. 
    
66.     while(1)
    
67.     {
    
68.         SPI1_L;        //开启片选
    
69.         HAL_SPI_Receive(&hspi1, (uint8_t *)&GetData, 1, 1000);
    
70.         Temperature = (GetData>>3)&0x0fff;
    
71.         SPI1_H;        
    
72.         HAL_Delay(1000);
    
73. 
    
74.         T = Temperature*1024/4095;
    
75.         printf ("Temperature:%d\n",T);
    
76.     }
    
77. }
    

复制代码

显示结果
有人能帮忙看看代码有什么问题吗？有一个问题请教：SPI配置支持16Bit数据，
但是HAL_StatusTypeDef HAL_SPI_Receive(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout)却是8Bit数据，应该怎么处理？

HAL_StatusTypeDef HAL_SPI_Receive(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout)

uint8_t *pData　这个是指针，可以传１６bit的数据，只要  Size =２就可以了。

无薪税绵 发表于 2017-1-21 08:23
HAL_StatusTypeDef HAL_SPI_Receive(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t T ...

1. HAL_StatusTypeDef HAL_SPI_Receive(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout)
   
2. {
   
3.   __IO uint16_t tmpreg;
   
4.   uint32_t tmp = 0;
   
5. 
   
6.   if(hspi->State == HAL_SPI_STATE_READY)
   
7.   {
   
8.     if((pData == NULL ) || (Size == 0))
   
9.     {
   
10.       return  HAL_ERROR;
    
11.     }
    
12. 
    
13.     /* Process Locked */
    
14.     __HAL_LOCK(hspi);
    
15. 
    
16.     /* Configure communication */
    
17.     hspi->State       = HAL_SPI_STATE_BUSY_RX;
    
18.     hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
    
19. 
    
20.     hspi->pRxBuffPtr  = pData;
    
21.     hspi->RxXferSize  = Size;
    
22.     hspi->RxXferCount = Size;
    
23. 
    
24.     /*Init field not used in handle to zero */
    
25.     hspi->RxISR = 0;
    
26.     hspi->TxISR = 0;
    
27.     hspi->TxXferSize   = 0;
    
28.     hspi->TxXferCount  = 0;
    
29. 
    
30.     /* Configure communication direction : 1Line */
    
31.     if(hspi->Init.Direction == SPI_DIRECTION_1LINE)
    
32.     {
    
33.       SPI_1LINE_RX(hspi);
    
34.     }
    
35. 
    
36.     /* Reset CRC Calculation */
    
37.     if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
    
38.     {
    
39.       SPI_RESET_CRC(hspi);
    
40.     }
    
41.    
    
42.     if((hspi->Init.Mode == SPI_MODE_MASTER) && (hspi->Init.Direction == SPI_DIRECTION_2LINES))
    
43.     {
    
44.       /* Process Unlocked */
    
45.       __HAL_UNLOCK(hspi);
    
46. 
    
47.       /* Call transmit-receive function to send Dummy data on Tx line and generate clock on CLK line */
    
48.       return HAL_SPI_TransmitReceive(hspi, pData, pData, Size, Timeout);
    
49.     }
    
50. 
    
51.     /* Check if the SPI is already enabled */
    
52.     if((hspi->Instance->CR1 &SPI_CR1_SPE) != SPI_CR1_SPE)
    
53.     {
    
54.       /* Enable SPI peripheral */
    
55.       __HAL_SPI_ENABLE(hspi);
    
56.     }
    
57. 
    
58.     /* Receive data in 8 Bit mode */
    
59.     if(hspi->Init.DataSize == SPI_DATASIZE_8BIT)
    
60.     {
    
61.       while(hspi->RxXferCount > 1)
    
62.       {
    
63.         /* Wait until RXNE flag is set */
    
64.         if(SPI_WaitOnFlagUntilTimeout(hspi, SPI_FLAG_RXNE, RESET, Timeout) != HAL_OK)
    
65.         {
    
66.           return HAL_TIMEOUT;
    
67.         }
    
68. 
    
69.         (*hspi->pRxBuffPtr++) = hspi->Instance->DR;
    
70.         hspi->RxXferCount--;
    
71.       }
    
72.       /* Enable CRC Transmission */
    
73.       if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
    
74.       {
    
75.         hspi->Instance->CR1 |= SPI_CR1_CRCNEXT;
    
76.       }
    
77.     }
    
78.     /* Receive data in 16 Bit mode */
    
79.     else
    
80.     {
    
81.       while(hspi->RxXferCount > 1)
    
82.       {
    
83.         /* Wait until RXNE flag is set to read data */
    
84.         if(SPI_WaitOnFlagUntilTimeout(hspi, SPI_FLAG_RXNE, RESET, Timeout) != HAL_OK)
    
85.         {
    
86.           return HAL_TIMEOUT;
    
87.         }
    
88. 
    
89.         *((uint16_t*)hspi->pRxBuffPtr) = hspi->Instance->DR;
    
90.         hspi->pRxBuffPtr+=2;
    
91.         hspi->RxXferCount--;
    
92.       }
    
93.       /* Enable CRC Transmission */
    
94.       if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
    
95.       {
    
96.         hspi->Instance->CR1 |= SPI_CR1_CRCNEXT;
    
97.       }
    
98.     }
    
99. 
    
100.     /* Wait until RXNE flag is set */
     
101.     if(SPI_WaitOnFlagUntilTimeout(hspi, SPI_FLAG_RXNE, RESET, Timeout) != HAL_OK)
     
102.     {
     
103.       return HAL_TIMEOUT;
     
104.     }
     
105. 
     
106.     /* Receive last data in 8 Bit mode */
     
107.     if(hspi->Init.DataSize == SPI_DATASIZE_8BIT)
     
108.     {
     
109.       (*hspi->pRxBuffPtr++) = hspi->Instance->DR;
     
110.     }
     
111.     /* [color=Red]Receive last data in 16 Bit mode [/color]*/
     
112.     else
     
113.     {
     
114.       *((uint16_t*)hspi->pRxBuffPtr) = hspi->Instance->DR;
     
115.       hspi->pRxBuffPtr+=2;
     
116.     }
     
117.     hspi->RxXferCount--;
     
118. 
     
119.     /* Wait until RXNE flag is set: CRC Received */
     
120.     if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
     
121.     {
     
122.       if(SPI_WaitOnFlagUntilTimeout(hspi, SPI_FLAG_RXNE, RESET, Timeout) != HAL_OK)
     
123.       {
     
124.         hspi->ErrorCode |= HAL_SPI_ERROR_CRC;
     
125.         return HAL_TIMEOUT;
     
126.       }
     
127. 
     
128.       /* Read CRC to Flush RXNE flag */
     
129.       tmpreg = hspi->Instance->DR;
     
130.       UNUSED(tmpreg);
     
131.     }
     
132.    
     
133.     if((hspi->Init.Mode == SPI_MODE_MASTER)&&((hspi->Init.Direction == SPI_DIRECTION_1LINE)||(hspi->Init.Direction == SPI_DIRECTION_2LINES_RXONLY)))
     
134.     {
     
135.       /* Disable SPI peripheral */
     
136.       __HAL_SPI_DISABLE(hspi);
     
137.     }
     
138. 
     
139.     hspi->State = HAL_SPI_STATE_READY;
     
140. 
     
141.     tmp = __HAL_SPI_GET_FLAG(hspi, SPI_FLAG_CRCERR);
     
142.     /* Check if CRC error occurred */
     
143.     if((hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE) && (tmp != RESET))
     
144.     {  
     
145.       hspi->ErrorCode |= HAL_SPI_ERROR_CRC;
     
146. 
     
147.       /* Reset CRC Calculation */
     
148.       SPI_RESET_CRC(hspi);
     
149. 
     
150.       /* Process Unlocked */
     
151.       __HAL_UNLOCK(hspi);
     
152. 
     
153.       return HAL_ERROR;
     
154.     }
     
155. 
     
156.     /* Process Unlocked */
     
157.     __HAL_UNLOCK(hspi);
     
158. 
     
159.     return HAL_OK;
     
160.   }
     
161.   else
     
162.   {
     
163.     return HAL_BUSY;
     
164.   }
     
165. }

复制代码

其中有针对16Bit的传输

jackten 发表于 2017-1-14 09:13
应该还有另外一条语句是传输16bit的

This section contains the following APIs:
HAL_SPI_Transmit()
HAL_SPI_Receive()
HAL_SPI_TransmitReceive()
HAL_SPI_Transmit_IT()
HAL_SPI_Receive_IT()
HAL_SPI_TransmitReceive_IT()
HAL_SPI_Transmit_DMA()
HAL_SPI_Receive_DMA()
HAL_SPI_TransmitReceive_DMA()
HAL_SPI_DMAPause()
HAL_SPI_DMAResume()
HAL_SPI_DMAStop()
HAL_SPI_IRQHandler()
HAL_SPI_TxCpltCallback()
HAL_SPI_RxCpltCallback()
HAL_SPI_TxRxCpltCallback()
HAL_SPI_TxHalfCpltCallback()
HAL_SPI_RxHalfCpltCallback()
HAL_SPI_TxRxHalfCpltCallback()
HAL_SPI_ErrorCallback()里面涉及到的参数uint8_t * pData、  uint8_t * pTxData、  uint8_t * pRxData都是8bit的，
昨晚有一位大哥让我定义为数组，然后组合起来，但是还是有问题，
uint8_t temp_buf[3] = {0};
while(1)
    {
        SPI1_L;        //开启片选
        HAL_SPI_Receive(&hspi1, temp_buf, 2, 1000);
        SPI1_H;
                Ret_MAX6675 = temp_buf[0]<<8 | temp_buf[1];
        T = (Ret_MAX6675>>3)&0x0fff;        
        HAL_Delay(1000);
               
        T = T*1024/4095;
        printf ("Temperature:%d\n",T);
    }

弄了好久了，头都大了。

应该还有另外一条语句是传输16bit的

是不是取样太快了，将所得的数据平均一下。

学习学习

无薪税绵 发表于 2017-1-21 08:23
HAL_StatusTypeDef HAL_SPI_Receive(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t T ...

赞成这个答案。

16位数的高低字节次序有没有反了？

本贴可以供你作参考：
https://www.stmcu.org.cn/module/forum/thread-566825-1-1.html
发送方式：
SPI_SendData8(SPI1,data);

接收你可以类推。

签到

zoomdy 发表于 2017-1-21 09:39
16位数的高低字节次序有没有反了？

确实应该注意一下顺序问题

当前显示的数据只有8bit，还缺一半呢，因此显示的结果肯定不正确

学习学习,谢谢楼主，支持分享

学习学习