Описание библиотеки микросхемы 5023ВС016 процессора "Спутник"
spi.c
См. документацию.
1 
29 #include "chip_5023BC016.h"
30 #include "system.h"
31 #include "spi.h"
32 #include "dma.h"
33 
34 
35 
41 void SPI_DeInit(SPI_T *pSPI)
42 {
43  SPI_Disable(pSPI);
47 }
48 
54 void SPI_Init(SPI_T *pSPI)
55 {
59 }
60 
67 {
68  CTRL_T CtrlSPI;
69  if (pSPI == SPI1)
70  {
71  CtrlSPI = SPI_1_CTRL_NUM;
72  }
73  else
74  {
75  CtrlSPI = SPI_2_CTRL_NUM;
76  }
77  return CtrlSPI;
78 }
79 
97 void SPI_SetFormat(SPI_T *pSPI, uint32_t pbits, uint32_t pframeFormat, uint32_t pclockMode)
98 {
99  pSPI->CR0 = (pSPI->CR0 & ~0xFF) | pbits | pframeFormat | pclockMode;
100 }
101 
111 void SPI_Set_Mode(SPI_T *pSPI, uint32_t pmode)
112 {
113  pSPI->CR1 = (pSPI->CR1 & ~(1 << 2)) | pmode;
114 }
115 
123 void SPI_SetClockRate(SPI_T *pSPI, uint32_t clk_rate, uint32_t prescale)
124 {
125  uint32_t temp;
126  temp = pSPI->CR0 & (~(SPI_CR0_SCR(0xFF)));
127  pSPI->CR0 = temp | (SPI_CR0_SCR(clk_rate));
128  pSPI->CPSR = prescale;
129 }
130 
137 void SPI_SetBitRate(SPI_T *pSPI, uint32_t bitRate)
138 {
139  uint32_t SPI_clk, cr0_div, cmp_clk, prescale;
140  SPI_clk = sys_freq;
141  cr0_div = 0;
142  cmp_clk = 0xFFFFFFFF;
143  prescale = 2;
144  while (cmp_clk > bitRate)
145  {
146  cmp_clk = SPI_clk / ((cr0_div + 1) * prescale);
147  if (cmp_clk > bitRate)
148  {
149  cr0_div++;
150  if (cr0_div > 0xFF)
151  {
152  cr0_div = 0;
153  prescale += 2;
154  }
155  }
156  }
157  SPI_SetClockRate(pSPI, cr0_div, prescale);
158 }
159 
165 uint8_t SPI_GetDataSize(SPI_T *pSPI)
166 {
167  return SPI_CR0_DSS(pSPI->CR0);
168 }
169 
176 void SPI_SendFrame(SPI_T *pSPI, uint16_t tx_data)
177 {
178  pSPI->DR = SPI_DR_DATA(tx_data);
179 }
180 
186 uint16_t SPI_ReceiveFrame(SPI_T *pSPI)
187 {
188  return (uint16_t)(SPI_DR_DATA(pSPI->DR));
189 }
190 
197 void SPI_Write1BFifo(SPI_T *pSPI, SPI_DATA_SETUP_T *xf_setup)
198 {
199  if (xf_setup->tx_data)
200  {
201  SPI_SendFrame(pSPI,
202  (*(uint8_t *) ((uint32_t) xf_setup->tx_data + xf_setup->tx_cnt)));
203  }
204  else
205  {
206  SPI_SendFrame(pSPI, 0xFF);
207  }
208  xf_setup->tx_cnt++;
209 }
210 
217 void SPI_Read1BFifo(SPI_T *pSPI, SPI_DATA_SETUP_T *xf_setup)
218 {
219  uint16_t rDat;
220  while ((SPI_GetStatus(pSPI, SPI_SR_RNE) == SET) && (xf_setup->rx_cnt < xf_setup->length))
221  {
222  rDat = SPI_ReceiveFrame(pSPI);
223  if (xf_setup->rx_data)
224  {
225  *(uint8_t *) ((uint32_t) xf_setup->rx_data + xf_setup->rx_cnt) = rDat;
226  }
227  xf_setup->rx_cnt++;
228  }
229 }
230 
237 void SPI_Write2BFifo(SPI_T *pSPI, SPI_DATA_SETUP_T *xf_setup)
238 {
239  if (xf_setup->tx_data)
240  {
241  SPI_SendFrame(pSPI, (*(uint16_t *) ((uint32_t) xf_setup->tx_data + xf_setup->tx_cnt)));
242  }
243  else
244  {
245  SPI_SendFrame(pSPI, 0xFFFF);
246  }
247  xf_setup->tx_cnt += 2;
248 }
249 
256 void SPI_Read2BFifo(SPI_T *pSPI, SPI_DATA_SETUP_T *xf_setup)
257 {
258  uint16_t rDat;
259  while ((SPI_GetStatus(pSPI, SPI_SR_RNE) == SET) && (xf_setup->rx_cnt < xf_setup->length))
260  {
261  rDat = SPI_ReceiveFrame(pSPI);
262  if (xf_setup->rx_data)
263  {
264  *(uint16_t *) ((uint32_t) xf_setup->rx_data + xf_setup->rx_cnt) = rDat;
265  }
266  xf_setup->rx_cnt += 2;
267  }
268 }
269 
276 uint32_t SPI_RWFrames_Blocking(SPI_T *pSPI, SPI_DATA_SETUP_T *xf_setup)
277 {
278  /* Очистка FIFO приемника */
279  while (SPI_GetStatus(pSPI, SPI_SR_RNE))
280  {
281  SPI_ReceiveFrame(pSPI);
282  }
283  /* Очистка статуса */
285  if (SPI_GetDataSize(pSPI) > SPI_BITS_8)
286  {
287  while (xf_setup->rx_cnt < xf_setup->length || xf_setup->tx_cnt < xf_setup->length)
288  {
289  /* запись данных в буфер */
290  if ((SPI_GetStatus(pSPI, SPI_SR_TNF) == SET) && (xf_setup->tx_cnt < xf_setup->length))
291  {
292  SPI_Write2BFifo(pSPI, xf_setup);
293  }
294  /* проверка наличия ошибки по переполнению */
295  if (SPI_GetRawIntStatus(pSPI, SPI_RIS_RORRIS) == SET)
296  {
297  return ERROR;
298  }
299  /* прооверка наличия данных в FIFO приемника*/
300  SPI_Read2BFifo(pSPI, xf_setup);
301  }
302  }
303  else
304  {
305  while (xf_setup->rx_cnt < xf_setup->length || xf_setup->tx_cnt < xf_setup->length)
306  {
307  /* запись данных в буфер */
308  if ((SPI_GetStatus(pSPI, SPI_SR_TNF) == SET) && (xf_setup->tx_cnt < xf_setup->length))
309  {
310  SPI_Write1BFifo(pSPI, xf_setup);
311  }
312  /* проверка наличия ошибки по переполнению */
313  if (SPI_GetRawIntStatus(pSPI, SPI_RIS_RORRIS) == SET)
314  {
315  return ERROR;
316  }
317  /* прооверка наличия данных в FIFO приемника*/
318  SPI_Read1BFifo(pSPI, xf_setup);
319  }
320  }
321  if (xf_setup->tx_data)
322  {
323  return xf_setup->tx_cnt;
324  }
325  else if (xf_setup->rx_data)
326  {
327  return xf_setup->rx_cnt;
328  }
329  return ERROR;
330 }
331 
339 uint32_t SPI_WriteFrames_Blocking(SPI_T *pSPI, uint8_t *buffer, uint32_t buffer_len)
340 {
341  uint32_t tx_cnt = 0, rx_cnt = 0;
342  /* Очистка FIFO приемника*/
343  while (SPI_GetStatus(pSPI, SPI_SR_RNE))
344  {
345  SPI_ReceiveFrame(pSPI);
346  }
347  /* Очистка статуса */
349  if (SPI_GetDataSize(pSPI) > SPI_BITS_8)
350  {
351  uint16_t *wdata16;
352  wdata16 = (uint16_t *) buffer;
353  while (tx_cnt < buffer_len || rx_cnt < buffer_len)
354  {
355  /* запись данных в буфер */
356  if ((SPI_GetStatus(pSPI, SPI_SR_TNF) == SET) && (tx_cnt < buffer_len))
357  {
358  SPI_SendFrame(pSPI, *wdata16);
359  wdata16++;
360  tx_cnt += 2;
361  }
362  /* проверка наличия ошибки по переполнению */
363  if (SPI_GetRawIntStatus(pSPI, SPI_RIS_RORRIS) == SET)
364  {
365  return ERROR;
366  }
367  /* прооверка наличия данных в FIFO приемника*/
368  while (SPI_GetStatus(pSPI, SPI_SR_RNE) == SET)
369  {
370  SPI_ReceiveFrame(pSPI);
371  rx_cnt += 2;
372  }
373  }
374  }
375  else
376  {
377  uint8_t *wdata8;
378  wdata8 = buffer;
379  while (tx_cnt < buffer_len || rx_cnt < buffer_len)
380  {
381  /* запись данных в буфер */
382  if ((SPI_GetStatus(pSPI, SPI_SR_TNF) == SET) && (tx_cnt < buffer_len))
383  {
384  SPI_SendFrame(pSPI, *wdata8);
385  wdata8++;
386  tx_cnt++;
387  }
388  /* проверка наличия ошибки по переполнению */
389  if (SPI_GetRawIntStatus(pSPI, SPI_RIS_RORRIS) == SET)
390  {
391  return ERROR;
392  }
393  /* прооверка наличия данных в FIFO приемника*/
394  while (SPI_GetStatus(pSPI, SPI_SR_RNE) == SET && rx_cnt < buffer_len)
395  {
396  SPI_ReceiveFrame(pSPI);
397  rx_cnt++;
398  }
399  }
400  }
401  return tx_cnt;
402 }
403 
411 uint32_t SPI_ReadFrames_Blocking(SPI_T *pSPI, uint8_t *buffer, uint32_t buffer_len)
412 {
413  uint32_t rx_cnt = 0, tx_cnt = 0;
414  /* Очистка FIFO приемника*/
415  while (SPI_GetStatus(pSPI, SPI_SR_RNE))
416  {
417  SPI_ReceiveFrame(pSPI);
418  }
419  /* Очистка статуса */
421  if (SPI_GetDataSize(pSPI) > SPI_BITS_8)
422  {
423  uint16_t *rdata16;
424  rdata16 = (uint16_t *) buffer;
425  while (tx_cnt < buffer_len || rx_cnt < buffer_len)
426  {
427  /* запись данных в буфер */
428  if ((SPI_GetStatus(pSPI, SPI_SR_TNF) == SET) && (tx_cnt < buffer_len))
429  {
430  SPI_SendFrame(pSPI, 0xFFFF);
431  tx_cnt += 2;
432  }
433  /* проверка наличия ошибки по переполнению */
434  if (SPI_GetRawIntStatus(pSPI, SPI_RIS_RORRIS) == SET)
435  {
436  return ERROR;
437  }
438  /* прооверка наличия данных в FIFO приемника*/
439  while (SPI_GetStatus(pSPI, SPI_SR_RNE) == SET && rx_cnt < buffer_len)
440  {
441  *rdata16 = SPI_ReceiveFrame(pSPI);
442  rdata16++;
443  rx_cnt += 2;
444  }
445  }
446  }
447  else
448  {
449  uint8_t *rdata8;
450  rdata8 = buffer;
451  while (tx_cnt < buffer_len || rx_cnt < buffer_len)
452  {
453  /* запись данных в буфер */
454  if ((SPI_GetStatus(pSPI, SPI_SR_TNF) == SET) && (tx_cnt < buffer_len))
455  {
456  SPI_SendFrame(pSPI, 0xFF);
457  tx_cnt++;
458  }
459  /* проверка наличия ошибки по переполнению */
460  if (SPI_GetRawIntStatus(pSPI, SPI_RIS_RORRIS) == SET)
461  {
462  return ERROR;
463  }
464  /* прооверка наличия данных в FIFO приемника*/
465  while (SPI_GetStatus(pSPI, SPI_SR_RNE) == SET && rx_cnt < buffer_len)
466  {
467  *rdata8 = SPI_ReceiveFrame(pSPI);
468  rdata8++;
469  rx_cnt++;
470  }
471  }
472  }
473  return rx_cnt;
474 }
475 
483 {
484  /* проверка наличия ошибки по переполнению в регистре RIS */
485  if (SPI_GetRawIntStatus(pSPI, SPI_RIS_RORRIS) == SET)
486  {
487  return ERROR;
488  }
489  if ((xf_setup->tx_cnt != xf_setup->length) || (xf_setup->rx_cnt != xf_setup->length))
490  {
491  /* прооверка наличия данных в FIFO приемника */
492  SPI_Read1BFifo(pSPI, xf_setup);
493  if ((SPI_GetStatus(pSPI, SPI_SR_TNF)) && (xf_setup->tx_cnt != xf_setup->length))
494  {
495  /* запись данных в буфер */
496  SPI_Write1BFifo(pSPI, xf_setup);
497  /* проверка наличия ошибки по переполнению в регистре RIS */
498  if (SPI_GetRawIntStatus(pSPI, SPI_RIS_RORRIS) == SET)
499  {
500  return ERROR;
501  }
502  /* прооверка наличия данных в FIFO приемника */
503  SPI_Read1BFifo(pSPI, xf_setup);
504  }
505  return SUCCESS;
506  }
507  return ERROR;
508 }
509 
517 {
518  /* проверка наличия ошибки по переполнению в регистре RIS */
519  if (SPI_GetRawIntStatus(pSPI, SPI_RIS_RORRIS) == SET)
520  {
521  return ERROR;
522  }
523  if ((xf_setup->tx_cnt != xf_setup->length) || (xf_setup->rx_cnt != xf_setup->length))
524  {
525  /* прооверка наличия данных в FIFO приемника */
526  SPI_Read2BFifo(pSPI, xf_setup);
527  if ((SPI_GetStatus(pSPI, SPI_SR_TNF)) && (xf_setup->tx_cnt != xf_setup->length))
528  {
529  /* запись данных в буфер */
530  SPI_Write2BFifo(pSPI, xf_setup);
531  /* проверка наличия ошибки по переполнению в регистре RIS */
532  if (SPI_GetRawIntStatus(pSPI, SPI_RIS_RORRIS) == SET)
533  {
534  return ERROR;
535  }
536  /* прооверка наличия данных в FIFO приемника */
537  SPI_Read2BFifo(pSPI, xf_setup);
538  }
539  return SUCCESS;
540  }
541  return ERROR;
542 }
543 
550 {
551  if (SPI_GetStatus(pSPI, SPI_SR_BSY))
552  {
553  while (SPI_GetStatus(pSPI, SPI_SR_BSY))
554  {
555  }
556  }
557  /* Очистка FIFO приемника*/
558  while (SPI_GetStatus(pSPI, SPI_SR_RNE))
559  {
560  SPI_ReceiveFrame(pSPI);
561  }
562  /* Очистка статуса */
564 }
565 
579 {
580  return (pSPI->SR & pStat) ? SET : RESET;
581 }
582 
595 {
596  return (pSPI->MIS & pMaskInt) ? SET : RESET;
597 }
598 
611 {
612  return (pSPI->RIS & pRawInt) ? SET : RESET;
613 }
614 
uint32_t SPI_RWFrames_Blocking(SPI_T *pSPI, SPI_DATA_SETUP_T *xf_setup)
Чтение/запись методом постоянного опроса.
Definition: spi.c:276
__RO uint32_t RIS
Definition: spi.h:46
void SPI_SendFrame(SPI_T *pSPI, uint16_t tx_data)
Отправка слова данных по интерфейсу SPI.
Definition: spi.c:176
SPI_RAWINTSTATUS_T
Тип для регистра RIS.
Definition: spi.h:144
Definition: types.h:76
Этот файл содержит структуры, макросы и функции необходимые для взаимодействия с контроллером прямого...
void SPI_Set_Mode(SPI_T *pSPI, uint32_t pmode)
Установка режима работы (ведущий или ведомый).
Definition: spi.c:111
void SPI_Write1BFifo(SPI_T *pSPI, SPI_DATA_SETUP_T *xf_setup)
Запись одного байта в буфер SPI.
Definition: spi.c:197
#define SPI_Disable(gl_spi_t)
Definition: spi.h:209
void SPI_Read2BFifo(SPI_T *pSPI, SPI_DATA_SETUP_T *xf_setup)
Чтение двух байт из буфера SPI.
Definition: spi.c:256
void PWR_RST_Enable(CTRL_T CTRLn)
Ввод модуля в асинхронный сброс
Definition: system.c:309
enum FlagStatus IntStatus
SPI_STATUS_T
Тип для регистра SR.
Definition: spi.h:115
#define SPI_ClearIntPending(gl_spi_t, gl_spi_intclr)
Definition: spi.h:237
CTRL_T
Номера модулей в регистрах PWR_CLK_CTRL и PWR_RST_CTRL Расшифровка битовых полей для регистров PWR_CT...
Definition: system.h:635
Status SPI_Int_RWFrames8Bits(SPI_T *pSPI, SPI_DATA_SETUP_T *xf_setup)
Чтение/запись 8 бит данных при помощи прерываний.
Definition: spi.c:482
uint32_t rx_cnt
Definition: spi.h:201
Этот файл содержит описание адресного пространства микроконтроллера 5023ВС016.
void SPI_Read1BFifo(SPI_T *pSPI, SPI_DATA_SETUP_T *xf_setup)
Чтение одного байта из буфера SPI.
Definition: spi.c:217
void SPI_SetClockRate(SPI_T *pSPI, uint32_t clk_rate, uint32_t prescale)
Установка скорости последовательного обмена: FSSPCLKOUT=FSSPCLK/(CPSDVR*(1+SCR))
Definition: spi.c:123
Status SPI_Int_RWFrames16Bits(SPI_T *pSPI, SPI_DATA_SETUP_T *xf_setup)
Чтение/запись 16 бит данных при помощи прерываний.
Definition: spi.c:516
uint32_t SPI_ReadFrames_Blocking(SPI_T *pSPI, uint8_t *buffer, uint32_t buffer_len)
Чтение методом постоянного опроса.
Definition: spi.c:411
void PWR_CLK_Disable(CTRL_T CTRLn)
Отключение тактового сигнала от модуля
Definition: system.c:328
Структура для доступа к регистрам SPI.
Definition: spi.h:38
#define SPI_CR0_SCR(x)
Definition: spi.h:56
Этот файл содержит структуры, макросы и функции необходимые для взаимодействия с интерфейсом SPI...
Definition: types.h:76
__RW uint32_t CPSR
Definition: spi.h:44
#define CLK_INIT_PAUSE
Definition: system.h:40
__RW uint32_t CR0
Definition: spi.h:40
__RW uint32_t DR
Definition: spi.h:42
void * tx_data
Definition: spi.h:198
FlagStatus
Тип для состояний флагов
Definition: types.h:64
void SPI_Init(SPI_T *pSPI)
Инициализация SPI.
Definition: spi.c:54
void SPI_SetFormat(SPI_T *pSPI, uint32_t pbits, uint32_t pframeFormat, uint32_t pclockMode)
Установка формата информационного кадра
Definition: spi.c:97
__RO uint32_t MIS
Definition: spi.h:47
void PWR_RST_Disable(CTRL_T CTRLn)
Вывод модуля из асинхронного сброса
Definition: system.c:318
#define SPI1
Указатель на структуру SPI1.
void PWR_CLK_Enable(CTRL_T CTRLn)
Подача тактового сигнала на модуль
Definition: system.c:337
FlagStatus SPI_GetStatus(SPI_T *pSPI, SPI_STATUS_T pStat)
Получение текущего статуса контроллера SPI.
Definition: spi.c:578
IntStatus SPI_GetRawIntStatus(SPI_T *pSPI, SPI_RAWINTSTATUS_T pRawInt)
Получение статуса прерывания.
Definition: spi.c:610
uint32_t length
Definition: spi.h:202
IntStatus SPI_GetIntStatus(SPI_T *pSPI, SPI_MASKINTSTATUS_T pMaskInt)
Получение статуса маскированного прерывания.
Definition: spi.c:594
Структура для работы с буфером SPI.
Definition: spi.h:196
uint32_t SPI_WriteFrames_Blocking(SPI_T *pSPI, uint8_t *buffer, uint32_t buffer_len)
Запись методом постоянного опроса.
Definition: spi.c:339
SPI_MASKINTSTATUS_T
Тип для регистра MIS.
Definition: spi.h:155
__RO uint32_t SR
Definition: spi.h:43
uint32_t tx_cnt
Definition: spi.h:199
Этот файл содержит структуры, макросы и функции необходимые для взаимодействия с регистрами общего на...
const unsigned int sys_freq
Definition: main.c:31
uint16_t SPI_ReceiveFrame(SPI_T *pSPI)
Прием слова данных по интерфейсу SPI.
Definition: spi.c:186
Definition: spi.h:64
Definition: types.h:64
Status
Тип для статуса операции
Definition: types.h:76
void SPI_DeInit(SPI_T *pSPI)
Сброс SPI.
Definition: spi.c:41
#define SPI_CR0_DSS(x)
Макросы и типы для регистра CR0.
Definition: spi.h:55
void SPI_Write2BFifo(SPI_T *pSPI, SPI_DATA_SETUP_T *xf_setup)
Запись двух байт в буфер SPI.
Definition: spi.c:237
#define SPI_DR_DATA(x)
Макросы для регистра DR.
Definition: spi.h:110
void SPI_Int_FlushData(SPI_T *pSPI)
Очистка буфера приемника и сброс флагов прерываний.
Definition: spi.c:549
void * rx_data
Definition: spi.h:200
__RW uint32_t CR1
Definition: spi.h:41
void SPI_SetBitRate(SPI_T *pSPI, uint32_t bitRate)
Установка частоты тактового сигнала для интерфейса SPI.
Definition: spi.c:137
Definition: types.h:64
CTRL_T SPI_GetCtrlNum(SPI_T *pSPI)
Возвращает номер модуля для использования в функциях включения/выключения SPI.
Definition: spi.c:66
uint8_t SPI_GetDataSize(SPI_T *pSPI)
Получение числа бит в одном слове данных.
Definition: spi.c:165