Appiko
SDK_EVAL_Spi_Driver.c
Go to the documentation of this file.
1 
24 /* Includes ------------------------------------------------------------------*/
25 #include "MCU_Interface.h"
26 #include "SDK_EVAL_Config.h"
27 #include "hal_spim.h"
28 #include "pin_trace.h"
29 #include "nrf_util.h"
30 #include "string.h"
31 #include "log.h"
32 
33 
49 #define CS_PIN CS
50 #define SDO_PIN MISO
51 #define SDI_PIN MOSI
52 #define SCK_PIN SCK
53 
54 
55 #define CS_TO_SCLK_DELAY 0x0001
56 #define CLK_TO_CS_DELAY 0x0001
57 
61 #define HEADER_WRITE_MASK 0x00
62 #define HEADER_READ_MASK 0x01
63 #define HEADER_ADDRESS_MASK 0x00
64 #define HEADER_COMMAND_MASK 0x80
66 #define LINEAR_FIFO_ADDRESS 0xFF
92 #define BUILT_HEADER(add_comm, w_r) (add_comm | w_r)
93 #define WRITE_HEADER BUILT_HEADER(HEADER_ADDRESS_MASK, HEADER_WRITE_MASK)
94 #define READ_HEADER BUILT_HEADER(HEADER_ADDRESS_MASK, HEADER_READ_MASK)
95 #define COMMAND_HEADER BUILT_HEADER(HEADER_COMMAND_MASK, HEADER_WRITE_MASK)
108 //static SPI_HandleTypeDef SpiHandle;
109 
120 //#define SPI_ENTER_CRITICAL() //__disable_irq()
121 //#define SPI_EXIT_CRITICAL() //__enable_irq()
122 
133 //#define SdkEvalSPICSLow() HAL_GPIO_WritePin(NUCLEO_SPI_PERIPH_CS_PORT, NUCLEO_SPI_PERIPH_CS_PIN, GPIO_PIN_RESET)
134 //#define SdkEvalSPICSHigh() HAL_GPIO_WritePin(NUCLEO_SPI_PERIPH_CS_PORT, NUCLEO_SPI_PERIPH_CS_PIN, GPIO_PIN_SET)
135 
141 void SdkEvalSpiDeinit(void)
142 {
143 // GPIO_InitTypeDef GPIO_InitStructure;
144 //
145 //
146 // /* Enable SPI periph and SCLK, MOSI, MISO and CS GPIO clocks */
147 // NUCLEO_SPI_CLK_ENABLE();
152 // NUCLEO_SPI_PERIPH_CS_CLK_ENABLE();
153 // NUCLEO_SPI_PERIPH_SCLK_CLK_ENABLE();
154 // NUCLEO_SPI_PERIPH_MISO_CLK_ENABLE();
155 // NUCLEO_SPI_PERIPH_MOSI_CLK_ENABLE();
156 //
157 // /* Configure the AF for MOSI, MISO and SCLK GPIO pins*/
158 // GPIO_InitStructure.Pin = NUCLEO_SPI_PERIPH_SCLK_PIN;
159 // GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;//GPIO_MODE_INPUT;
160 // GPIO_InitStructure.Pull = GPIO_NOPULL;
161 // GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
162 //
163 // HAL_GPIO_Init(NUCLEO_SPI_PERIPH_SCLK_PORT, &GPIO_InitStructure);
164 //
165 // GPIO_InitStructure.Pin = NUCLEO_SPI_PERIPH_MISO_PIN;
166 //
167 // HAL_GPIO_Init(NUCLEO_SPI_PERIPH_MISO_PORT, &GPIO_InitStructure);
168 //
169 // GPIO_InitStructure.Pin = NUCLEO_SPI_PERIPH_MOSI_PIN;
170 //
171 // HAL_GPIO_Init(NUCLEO_SPI_PERIPH_MOSI_PORT, &GPIO_InitStructure);
172 //
173 // GPIO_InitStructure.Pin = NUCLEO_SPI_PERIPH_CS_PIN;
174 // GPIO_InitStructure.Mode = GPIO_MODE_INPUT;
175 // HAL_GPIO_Init(NUCLEO_SPI_PERIPH_CS_PORT, &GPIO_InitStructure);
176 //
177 // HAL_GPIO_WritePin(NUCLEO_SPI_PERIPH_MOSI_PORT,NUCLEO_SPI_PERIPH_MOSI_PIN,GPIO_PIN_SET);
178 // HAL_GPIO_WritePin(NUCLEO_SPI_PERIPH_MISO_PORT,NUCLEO_SPI_PERIPH_MISO_PIN,GPIO_PIN_SET);
179 //
180 // /* Configure SPI peripheral */
181 // if(HAL_SPI_GetState(&SpiHandle) == HAL_SPI_STATE_RESET)
182 // {
183 // /* Set the SPI parameters */
184 // SpiHandle.Instance = NUCLEO_SPI_PERIPH_NB;
185 // SpiHandle.Init.Mode = SPI_MODE_MASTER;
186 // SpiHandle.Init.BaudRatePrescaler = SDK_EVAL_SPI_PRESCALER;
187 //
188 // SpiHandle.Init.Direction = SPI_DIRECTION_2LINES;
189 // SpiHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
190 // SpiHandle.Init.CLKPolarity = SPI_POLARITY_LOW;
191 // SpiHandle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
192 // SpiHandle.Init.CRCPolynomial = 7;
193 // SpiHandle.Init.DataSize = SPI_DATASIZE_8BIT;
194 // SpiHandle.Init.FirstBit = SPI_FIRSTBIT_MSB;
195 // SpiHandle.Init.NSS = SPI_NSS_SOFT;
196 // SpiHandle.Init.TIMode = SPI_TIMODE_DISABLED;
197 //
198 // if(HAL_SPI_DeInit(&SpiHandle) != HAL_OK) {
199 // return;
200 // }
201 // __HAL_SPI_DISABLE(&SpiHandle);
202 // }
203  hal_spim_deinit ();
204 }
205 
206 
213 //void SdkEvalSpiSetBaudrate(uint32_t baudrate_prescaler)
214 //{
215 // __HAL_SPI_DISABLE(&SpiHandle);
216 //
217 // SpiHandle.Init.BaudRatePrescaler = baudrate_prescaler;
218 //
219 // if(HAL_SPI_Init(&SpiHandle) != HAL_OK) {
220 // return;
221 // }
222 // __HAL_SPI_ENABLE(&SpiHandle);
223 //
224 //}
225 
231 void SdkEvalSpiInit(void)
232 {
233 // GPIO_InitTypeDef GPIO_InitStructure;
234 //
235 // /* Enable SPI periph and SCLK, MOSI, MISO and CS GPIO clocks */
236 // NUCLEO_SPI_CLK_ENABLE();
237 // NUCLEO_SPI_PERIPH_CS_CLK_ENABLE();
238 // NUCLEO_SPI_PERIPH_SCLK_CLK_ENABLE();
239 // NUCLEO_SPI_PERIPH_MISO_CLK_ENABLE();
240 // NUCLEO_SPI_PERIPH_MOSI_CLK_ENABLE();
241 //
242 //
243 // /* Configure the AF for MOSI, MISO and SCLK GPIO pins*/
244 // GPIO_InitStructure.Pin = NUCLEO_SPI_PERIPH_SCLK_PIN;
245 // GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
246 // GPIO_InitStructure.Pull = GPIO_PULLUP;
247 // GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
248 // GPIO_InitStructure.Alternate = NUCLEO_SPI_PERIPH_SCLK_AF;
249 // HAL_GPIO_Init(NUCLEO_SPI_PERIPH_SCLK_PORT, &GPIO_InitStructure);
250 //
251 // GPIO_InitStructure.Pin = NUCLEO_SPI_PERIPH_MISO_PIN;
252 // GPIO_InitStructure.Alternate = NUCLEO_SPI_PERIPH_MISO_AF;
253 // HAL_GPIO_Init(NUCLEO_SPI_PERIPH_MISO_PORT, &GPIO_InitStructure);
254 //
255 // GPIO_InitStructure.Pin = NUCLEO_SPI_PERIPH_MOSI_PIN;
256 // GPIO_InitStructure.Alternate = NUCLEO_SPI_PERIPH_MOSI_AF;
257 // HAL_GPIO_Init(NUCLEO_SPI_PERIPH_MOSI_PORT, &GPIO_InitStructure);
258 //
259 // GPIO_InitStructure.Pin = NUCLEO_SPI_PERIPH_CS_PIN;
260 // GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
261 // HAL_GPIO_Init(NUCLEO_SPI_PERIPH_CS_PORT, &GPIO_InitStructure);
262 //
263 //
264 // /* Configure SPI peripheral */
265 // if(HAL_SPI_GetState(&SpiHandle) == HAL_SPI_STATE_RESET)
266 // {
267 // /* Set the SPI parameters */
268 // SpiHandle.Instance = NUCLEO_SPI_PERIPH_NB;
269 // SpiHandle.Init.Mode = SPI_MODE_MASTER;
270 // SpiHandle.Init.BaudRatePrescaler = SDK_EVAL_SPI_PRESCALER;
271 //
272 // SpiHandle.Init.Direction = SPI_DIRECTION_2LINES;
273 // SpiHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
274 // SpiHandle.Init.CLKPolarity = SPI_POLARITY_LOW;
275 // SpiHandle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
276 // SpiHandle.Init.CRCPolynomial = 7;
277 // SpiHandle.Init.DataSize = SPI_DATASIZE_8BIT;
278 // SpiHandle.Init.FirstBit = SPI_FIRSTBIT_MSB;
279 // SpiHandle.Init.NSS = SPI_NSS_SOFT;
280 // SpiHandle.Init.TIMode = SPI_TIMODE_DISABLED;
281 //
282 // if(HAL_SPI_Init(&SpiHandle) != HAL_OK) {
283 // while(1);
284 // }
285 // __HAL_SPI_ENABLE(&SpiHandle);
286 // }
287 //
288 // SdkEvalSPICSHigh();
289  hal_spim_init_t default_spim_config =
290  {
291  .csBar_pin = CS_PIN,
292  .miso_pin = SDO_PIN,
293  .mosi_pin = SDI_PIN,
294  .sck_pin = SCK_PIN,
295  .freq = HAL_SPIM_FREQ_250K,
296  .spi_mode = HAL_SPIM_SPI_MODE0,
297  .byte_order = HAL_SPIM_MSB_FIRST,
298  .en_intr = 0,
299  .tx_done_handler = NULL,
300  .rx_done_handler = NULL,
301 
302  };
303  hal_spim_init (&default_spim_config);
304 }
305 
306 
314 StatusBytes SdkEvalSpiWriteRegisters(uint8_t cRegAddress, uint8_t cNbBytes, uint8_t* pcBuffer)
315 {
316  uint8_t tx_buff[257];
317  tx_buff[0] = WRITE_HEADER;
318  tx_buff[1] = cRegAddress;
319  uint8_t rx_buff[2];
320  memcpy (&tx_buff[2], pcBuffer, cNbBytes);
321  StatusBytes status;
322 
323 
324  hal_spim_tx_rx (tx_buff, cNbBytes+2, rx_buff, 2);
325  while(hal_spim_is_busy ());
326 
327  ((uint8_t*)&status)[1]=rx_buff[0];
328  ((uint8_t*)&status)[0]=rx_buff[1];
329 
330  return status;
331 
332 }
333 
341 StatusBytes SdkEvalSpiReadRegisters(uint8_t cRegAddress, uint8_t cNbBytes, uint8_t* pcBuffer)
342 {
343  uint8_t tx_buff[255]={READ_HEADER,cRegAddress};
344  uint8_t temp_buff[255];
345  StatusBytes status;
346 
347  hal_spim_tx_rx (tx_buff, 2, temp_buff, cNbBytes+2);
348  while(hal_spim_is_busy ());
349 
350  memcpy (pcBuffer, &temp_buff[2],cNbBytes);
351 
352  ((uint8_t*)&status)[1]=temp_buff[0];
353  ((uint8_t*)&status)[0]=temp_buff[1];
354 
355  return status;
356 }
357 
363 StatusBytes SdkEvalSpiCommandStrobes(uint8_t cCommandCode)
364 {
365  uint8_t tx_buff[2]={COMMAND_HEADER,cCommandCode};
366  uint8_t rx_buff[2];
367  StatusBytes status;
368 
369  hal_spim_tx_rx (tx_buff, 2, rx_buff, 2);
370  while(hal_spim_is_busy ());
371 
372  ((uint8_t*)&status)[1]=rx_buff[0];
373  ((uint8_t*)&status)[0]=rx_buff[1];
374 
375  return status;
376 }
377 
378 
385 StatusBytes SdkEvalSpiWriteFifo(uint8_t cNbBytes, uint8_t* pcBuffer)
386 {
387  uint8_t tx_buff[cNbBytes + 2];
388  tx_buff[0] = WRITE_HEADER;
389  tx_buff[1] = LINEAR_FIFO_ADDRESS;
390  memcpy (&tx_buff[2], pcBuffer, cNbBytes);
391  uint8_t rx_buff[2];
392  StatusBytes status;
393 
394  hal_spim_tx_rx (tx_buff, cNbBytes+2, rx_buff, 2);
395  while(hal_spim_is_busy ());
396 
397  ((uint8_t*)&status)[1]=rx_buff[0];
398  ((uint8_t*)&status)[0]=rx_buff[1];
399 
400  return status;
401 }
402 
403 
410 StatusBytes SdkEvalSpiReadFifo(uint8_t cNbBytes, uint8_t* pcBuffer)
411 {
412  uint8_t tx_buff[2]={READ_HEADER,LINEAR_FIFO_ADDRESS};
413  uint8_t rx_buff[2];
414  uint8_t temp_buff[255];
415  StatusBytes status;
416 
417  hal_spim_tx_rx (tx_buff, 2, rx_buff, 2);
418  while(hal_spim_is_busy ());
419  hal_spim_tx_rx (tx_buff, 2, temp_buff, cNbBytes+2);
420  while(hal_spim_is_busy ());
421 
422  memcpy (pcBuffer, &temp_buff[2],cNbBytes);
423 
424  ((uint8_t*)&status)[1]=rx_buff[0];
425  ((uint8_t*)&status)[0]=rx_buff[1];
426 
427 
428  return status;
429 
430 }
431 
432 //SPI_HandleTypeDef* SdkEvalSpiGetStruct(void)
433 //{
434 // return &SpiHandle;
435 //}
436 
453 /******************* (C) COPYRIGHT 2013 STMicroelectronics *****END OF FILE****/
READ_HEADER
#define READ_HEADER
Definition: SDK_EVAL_Spi_Driver.c:94
SdkEvalSpiCommandStrobes
StatusBytes SdkEvalSpiCommandStrobes(uint8_t cCommandCode)
Send a command.
Definition: SDK_EVAL_Spi_Driver.c:363
hal_spim_init
void hal_spim_init(hal_spim_init_t *spim_init)
Function to Initiate the SPIM module.
Definition: hal_spim.c:60
HAL_SPIM_SPI_MODE0
Definition: hal_spim.h:65
hal_spim_init_t::csBar_pin
uint32_t csBar_pin
Definition: hal_spim.h:96
SDK_EVAL_Config.h
This file contains SDK EVAL configuration and useful defines.
SdkEvalSpiWriteFifo
StatusBytes SdkEvalSpiWriteFifo(uint8_t cNbBytes, uint8_t *pcBuffer)
Write data into TX FIFO.
Definition: SDK_EVAL_Spi_Driver.c:385
hal_spim_tx_rx
void hal_spim_tx_rx(void *p_tx_data, uint32_t tx_len, void *p_rx_data, uint32_t rx_len)
Function to start communication.
Definition: hal_spim.c:108
SdkEvalSpiReadFifo
StatusBytes SdkEvalSpiReadFifo(uint8_t cNbBytes, uint8_t *pcBuffer)
Read data from RX FIFO.
Definition: SDK_EVAL_Spi_Driver.c:410
SdkEvalSpiReadRegisters
StatusBytes SdkEvalSpiReadRegisters(uint8_t cRegAddress, uint8_t cNbBytes, uint8_t *pcBuffer)
Read single or multiple registers.
Definition: SDK_EVAL_Spi_Driver.c:341
HAL_SPIM_MSB_FIRST
Definition: hal_spim.h:78
S2LPStatus
S2LP Status. This definition represents the single field of the S2LP status returned on each SPI tran...
Definition: S2LP_Types.h:117
hal_spim_init_t
Definition: hal_spim.h:93
COMMAND_HEADER
#define COMMAND_HEADER
Definition: SDK_EVAL_Spi_Driver.c:95
SdkEvalSpiInit
void SdkEvalSpiInit(void)
Write single or multiple registers.
Definition: SDK_EVAL_Spi_Driver.c:231
SdkEvalSpiWriteRegisters
StatusBytes SdkEvalSpiWriteRegisters(uint8_t cRegAddress, uint8_t cNbBytes, uint8_t *pcBuffer)
Write single or multiple registers.
Definition: SDK_EVAL_Spi_Driver.c:314
LINEAR_FIFO_ADDRESS
#define LINEAR_FIFO_ADDRESS
Definition: SDK_EVAL_Spi_Driver.c:66
WRITE_HEADER
#define WRITE_HEADER
Definition: SDK_EVAL_Spi_Driver.c:93
hal_spim_deinit
void hal_spim_deinit()
Function to de-initialize the SPIM module.
Definition: hal_spim.c:97
MCU_Interface.h
Header file for low level S2LP SPI driver.
SdkEvalSpiDeinit
void SdkEvalSpiDeinit(void)
Deinitializes the SPI.
Definition: SDK_EVAL_Spi_Driver.c:141
hal_spim_is_busy
uint32_t hal_spim_is_busy()
Function to check if SIPM module is available or not.
Definition: hal_spim.c:135
Generated by   doxygen 1.8.15