21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › NUC505的SPIM能当作普通SPI使用吗？
返回列表 发新帖我要提问

[技术问答] NUC505的SPIM能当作普通SPI使用吗？

[复制链接]
2894|8
 楼主| subo19920716 发表于 2017-5-12 22:56 | 显示全部楼层 |阅读模式
NUC, spi, DMA, DM, AC
准备使用NUC505DL13Y做一项目，其他功能都做得差不多了，还有SPI部分没有调试，之前看了手册上说SPI支持DMA传输，就没太在意。现在回过头来仔细一看，才发现这是一个坑。
1.png
NUC505根本就没有PDMA，剩下一个SPIM支持DMA，貌似是SPI Flash专用SPI接口，不知能否当作普通SPI使用？

回复

收藏 举报

相关帖子
xyz549040622 发表于 2017-5-13 07:00 | 显示全部楼层
试试不就知道了么，一般情况下，通常都是兼容的。
回复

收藏 举报

zhuotuzi 发表于 2017-5-13 22:02 | 显示全部楼层
应该可以的。
回复

收藏 举报

zhuotuzi 发表于 2017-5-13 22:03 | 显示全部楼层
实在不行就用3根GPIO来做，IO模拟的SPI更简单。。
回复

收藏 举报

zhuotuzi 发表于 2017-5-13 23:37 | 显示全部楼层
我经常是用硬件的搞不定了，就直接IO模拟
回复

收藏 举报

天灵灵地灵灵 发表于 2017-5-16 15:04 | 显示全部楼层
官方没有提供这个的例程吗，如果不行，就来模拟的。
回复

收藏 举报

天灵灵地灵灵 发表于 2017-5-16 15:08 | 显示全部楼层
复制
  1. /**************************************************************************//**
    

  2.  * [url=home.php?mod=space&uid=288409]@file[/url]     main.c
    

  3.  * [url=home.php?mod=space&uid=895143]@version[/url]  V2.0
    

  4.  * $Revision: 4 $
    

  5.  * $Date: 15/03/04 9:49a $
    

  6.  * [url=home.php?mod=space&uid=247401]@brief[/url]    Demonstrate how to communicate with an off-chip SPI slave device. This sample code needs to work with SPI_SlaveMode.
    

  7.  *
    

  8.  * @note
    

  9.  * Copyright (C) 2015 Nuvoton Technology Corp. All rights reserved.
    

  10.  *
    

  11.  ******************************************************************************/
    

  12. #include <stdio.h>
    

  13. #include "NUC505Series.h"
    


  14. 


  15. 

  16. #define TEST_COUNT 16
    


  17. 

  18. uint32_t g_au32SourceData[TEST_COUNT];
    

  19. uint32_t g_au32DestinationData[TEST_COUNT];
    

  20. volatile uint32_t g_u32TxDataCount;
    

  21. volatile uint32_t g_u32RxDataCount;
    


  22. 

  23. /* Function prototype declaration */
    

  24. void SYS_Init(void);
    

  25. void UART0_Init(void);
    

  26. void SPI1_Init(void);
    


  27. 

  28. /* ------------- */
    

  29. /* Main function */
    

  30. /* ------------- */
    

  31. int main(void)
    

  32. {
    

  33.     uint32_t u32DataCount;
    


  34. 

  35.     /* Init System, IP clock and multi-function I/O. */
    

  36.     SYS_Init();
    

  37.     
    

  38.                 /* Init UART0 to 115200-8n1 for print message */
    

  39.     UART0_Init();
    

  40.                 
    

  41.                 /* Init SPI1, IP clock and multi-function I/O */
    

  42.                 SPI1_Init();
    


  43. 

  44.     printf("\n\n");
    

  45.     printf("+--------------------------------------------------------+\n");
    

  46.     printf("|             SPI Master Mode Sample Code                |\n");
    

  47.     printf("+--------------------------------------------------------+\n");
    

  48.     printf("\n");
    

  49.     printf("Configure SPI1 as a master.\n");
    

  50.     printf("Bit length of a transaction: 32\n");
    

  51.     printf("The I/O connection for SPI1:\n");
    

  52.     printf("    SPI1_SS (PB.10)\n    SPI1_CLK (PB.11)\n");
    

  53.     printf("    SPI1_MOSI (PB.12)\n    SPI1_MISO (PB.13)\n\n");
    

  54.     printf("SPI controller will transfer %d data to a off-chip slave device.\n", TEST_COUNT);
    

  55.     printf("In the meanwhile the SPI controller will receive %d data from the off-chip slave device.\n", TEST_COUNT);
    

  56.     printf("After the transfer is done, the %d received data will be printed out.\n", TEST_COUNT);
    

  57.     printf("The SPI master configuration is ready.\n");
    


  58. 

  59.     for(u32DataCount = 0; u32DataCount < TEST_COUNT; u32DataCount++)
    

  60.     {
    

  61.         /* Write the initial value to source buffer */
    

  62.         g_au32SourceData[u32DataCount] = 0x00550000 + u32DataCount;
    

  63.         /* Clear destination buffer */
    

  64.         g_au32DestinationData[u32DataCount] = 0;
    

  65.     }
    


  66. 

  67.                 SPI_ENABLE(SPI1);
    

  68.     printf("Before starting the data transfer, make sure the slave device is ready. Press any key to start the transfer.");
    

  69.     getchar();
    

  70.     printf("\n");
    


  71. 

  72.     /* Set TX FIFO threshold, enable TX FIFO threshold interrupt and RX FIFO time-out interrupt */
    

  73.     SPI_SetFIFO(SPI1, 4, 4);
    

  74.     SPI_EnableInt(SPI1, SPI_FIFO_TXTH_INT_MASK | SPI_FIFO_RXTO_INT_MASK);
    

  75.     g_u32TxDataCount = 0;
    

  76.     g_u32RxDataCount = 0;
    

  77.     NVIC_EnableIRQ(SPI1_IRQn);
    


  78. 

  79.     /* Wait for transfer done */
    

  80.     while(g_u32RxDataCount < TEST_COUNT);
    


  81. 

  82.     /* Print the received data */
    

  83.     printf("Received data:\n");
    

  84.     for(u32DataCount = 0; u32DataCount < TEST_COUNT; u32DataCount++)
    

  85.     {
    

  86.         printf("%d:\t0x%X\n", u32DataCount, g_au32DestinationData[u32DataCount]);
    

  87.     }
    

  88.     /* Disable TX FIFO threshold interrupt and RX FIFO time-out interrupt */
    

  89.     SPI_DisableInt(SPI1, SPI_FIFO_TXTH_INT_MASK | SPI_FIFO_RXTO_INT_MASK);
    

  90.     NVIC_DisableIRQ(SPI1_IRQn);
    

  91.     printf("The data transfer was done.\n");
    


  92. 

  93.     printf("\n\nExit SPI driver sample code.\n");
    


  94. 

  95.     /* Disable SPI1 peripheral clock */
    

  96.     SPI_Close(SPI1);
    

  97.     while(1);
    

  98. }
    


  99. 

  100. void SPI1_IRQHandler(void)
    

  101. {
    

  102.     uint32_t u32Tmp;
    

  103.     
    

  104.     /* Check RX EMPTY flag */
    

  105.     while(SPI_GET_RX_FIFO_EMPTY_FLAG(SPI1) == 0)
    

  106.     {
    

  107.         u32Tmp = g_u32RxDataCount;
    

  108.         /* Read RX FIFO */
    

  109.         g_au32DestinationData[u32Tmp++] = SPI_READ_RX(SPI1);
    

  110.         g_u32RxDataCount = u32Tmp;
    

  111.     }
    

  112.     /* Check TX FULL flag and TX data count */
    

  113.     while((SPI_GET_TX_FIFO_FULL_FLAG(SPI1) == 0) && (g_u32TxDataCount < TEST_COUNT))
    

  114.     {
    

  115.         /* Write to TX FIFO */
    

  116.         SPI_WRITE_TX(SPI1, g_au32SourceData[g_u32TxDataCount++]);
    

  117.     }
    

  118.     if(g_u32TxDataCount >= TEST_COUNT)
    

  119.         SPI_DisableInt(SPI1, SPI_FIFO_TXTH_INT_MASK); /* Disable TX FIFO threshold interrupt */
    


  120. 

  121.     /* Check the RX FIFO time-out interrupt flag */
    

  122.     if(SPI_GetIntFlag(SPI1, SPI_FIFO_RXTO_INT_MASK))
    

  123.     {
    

  124.         /* If RX FIFO is not empty, read RX FIFO. */
    

  125.         while(SPI_GET_RX_FIFO_EMPTY_FLAG(SPI1) == 0)
    

  126.         {
    

  127.             u32Tmp = g_u32RxDataCount;
    

  128.             g_au32DestinationData[u32Tmp++] = SPI_READ_RX(SPI1);
    

  129.             g_u32RxDataCount = u32Tmp;
    

  130.         }
    

  131.     }
    

  132. }
    


  133. 

  134. void SYS_Init(void)
    

  135. {
    


  136. 

  137. /*---------------------------------------------------------------------------------------------------------*/
    

  138. /* Init System Clock                                                                                       */
    

  139. /*---------------------------------------------------------------------------------------------------------*/
    

  140.     /* Unlock protected registers */
    

  141.     //SYS_UnlockReg();
    

  142.      
    

  143.     /* Enable  XTAL */
    

  144.     CLK->PWRCTL |= CLK_PWRCTL_HXTEN_Msk;
    


  145. 

  146.     CLK_SetCoreClock(FREQ_96MHZ);
    

  147.     
    

  148.                 /* PCLK divider */
    

  149.                 CLK_SetModuleClock(PCLK_MODULE, NULL, 1);
    

  150.                 
    

  151.     /* Lock protected registers */
    

  152.     //SYS_LockReg();
    

  153.         
    

  154. }
    


  155. 

  156. void UART0_Init(void)
    

  157. {
    

  158.                 /* Enable UART0 Module clock */
    

  159.     CLK_EnableModuleClock(UART0_MODULE);
    

  160.                 /* UART0 module clock from EXT */
    

  161.                 CLK_SetModuleClock(UART0_MODULE, CLK_UART0_SRC_EXT, 0);
    

  162.     /* Reset IP */
    

  163.     SYS_ResetModule(UART0_RST);    
    

  164.     /* Configure UART0 and set UART0 Baud-rate */
    

  165.                 UART_Open(UART0, 115200);
    

  166.                 /*---------------------------------------------------------------------------------------------------------*/
    

  167.     /* Init I/O Multi-function                                                                                 */
    

  168.     /*---------------------------------------------------------------------------------------------------------*/
    

  169.     /* Configure multi-function pins for UART0 RXD and TXD */
    

  170.                 SYS->GPB_MFPL  = (SYS->GPB_MFPL & (~SYS_GPB_MFPL_PB0MFP_Msk) ) | SYS_GPB_MFPL_PB0MFP_UART0_TXD;        
    

  171.                 SYS->GPB_MFPL  = (SYS->GPB_MFPL & (~SYS_GPB_MFPL_PB1MFP_Msk) ) | SYS_GPB_MFPL_PB1MFP_UART0_RXD;        
    

  172.         
    

  173. }
    


  174. 

  175. void SPI1_Init(void)
    

  176. {
    

  177.                 /* Enable SPI1 Module clock */
    

  178.     CLK_EnableModuleClock(SPI1_MODULE);
    

  179.                 /* SPI1 module clock from EXT */
    

  180.                 CLK_SetModuleClock(SPI1_MODULE, CLK_SPI1_SRC_PLL, 0);
    

  181.     /* Reset IP */
    

  182.     SYS_ResetModule(SPI1_RST);    
    

  183.     /*---------------------------------------------------------------------------------------------------------*/
    

  184.     /* Init I/O Multi-function                                                                                 */
    

  185.     /*---------------------------------------------------------------------------------------------------------*/
    

  186.     /* Configure multi-function pins for SPI1 */
    

  187.                 SYS->GPB_MFPH  = (SYS->GPB_MFPH & (~SYS_GPB_MFPH_PB10MFP_Msk) ) | SYS_GPB_MFPH_PB10MFP_SPI1_SS;        
    

  188.                 SYS->GPB_MFPH  = (SYS->GPB_MFPH & (~SYS_GPB_MFPH_PB11MFP_Msk) ) | SYS_GPB_MFPH_PB11MFP_SPI1_CLK;        
    

  189.                 SYS->GPB_MFPH  = (SYS->GPB_MFPH & (~SYS_GPB_MFPH_PB12MFP_Msk) ) | SYS_GPB_MFPH_PB12MFP_SPI1_MOSI;        
    

  190.                 SYS->GPB_MFPH  = (SYS->GPB_MFPH & (~SYS_GPB_MFPH_PB13MFP_Msk) ) | SYS_GPB_MFPH_PB13MFP_SPI1_MISO;        
    


  191. 

  192.                 /*---------------------------------------------------------------------------------------------------------*/
    

  193.     /* Init SPI                                                                                                */
    

  194.     /*---------------------------------------------------------------------------------------------------------*/
    

  195.     /* Configure SPI1 as a master, SPI clock rate 200 KHz,
    

  196.        clock idle low, 32-bit transaction, drive output on falling clock edge and latch input on rising edge. */
    

  197.     SPI_Open(SPI1, SPI_MASTER, SPI_MODE_0, 32, 200000);
    

  198.     /* Enable the automatic hardware slave selection function. Select the SPI1_SS pin and configure as low-active. */
    

  199.     SPI_EnableAutoSS(SPI1, SPI_SS, SPI_SS_ACTIVE_LOW);
    

  200. }
    


  201. 

  202. /*** (C) COPYRIGHT 2015 Nuvoton Technology Corp. ***/
回复

收藏 举报

天灵灵地灵灵 发表于 2017-5-16 15:09 | 显示全部楼层
复制
  1. /**************************************************************************//**
    

  2.  * @file     main.c
    

  3.  * @version  V2.0
    

  4.  * $Revision: 4 $
    

  5.  * $Date: 15/03/04 9:49a $
    

  6.  * @brief    Demonstrate how to communicate with an off-chip SPI master device. This sample code needs to work with SPI_MasterMode.
    

  7.  *
    

  8.  * @note
    

  9.  * Copyright (C) 2015 Nuvoton Technology Corp. All rights reserved.
    

  10.  *
    

  11.  ******************************************************************************/
    

  12. #include <stdio.h>
    

  13. #include "NUC505Series.h"
    


  14. 


  15. 

  16. #define TEST_COUNT 16
    


  17. 

  18. uint32_t g_au32SourceData[TEST_COUNT];
    

  19. uint32_t g_au32DestinationData[TEST_COUNT];
    

  20. volatile uint32_t g_u32TxDataCount;
    

  21. volatile uint32_t g_u32RxDataCount;
    


  22. 

  23. /* Function prototype declaration */
    

  24. void SYS_Init(void);
    

  25. void UART0_Init(void);
    

  26. void SPI1_Init(void);
    


  27. 

  28. /* ------------- */
    

  29. /* Main function */
    

  30. /* ------------- */
    

  31. int main(void)
    

  32. {
    

  33.     volatile uint32_t u32TxDataCount, u32RxDataCount;
    

  34.     uint32_t u32Tmp;
    


  35. 

  36.     /* Init System, IP clock and multi-function I/O. */
    

  37.     SYS_Init();
    

  38.     
    

  39.                 /* Init UART0 to 115200-8n1 for print message */
    

  40.     UART0_Init();
    

  41.                 
    

  42.                 /* Init SPI1, IP clock and multi-function I/O */
    

  43.                 SPI1_Init();
    


  44. 

  45.     printf("\n\n");
    

  46.     printf("+-----------------------------------------------------+\n");
    

  47.     printf("|           SPI Slave Mode Sample Code                |\n");
    

  48.     printf("+-----------------------------------------------------+\n");
    

  49.     printf("\n");
    

  50.     printf("Configure SPI1 as a slave.\n");
    

  51.     printf("Bit length of a transaction: 32\n");
    

  52.     printf("The I/O connection for SPI1:\n");
    

  53.     printf("    SPI1_SS (PB.10)\n    SPI1_CLK (PB.11)\n");
    

  54.     printf("    SPI1_MOSI (PB.12)\n    SPI1_MISO (PB.13)\n\n");
    

  55.     printf("SPI controller will transfer %d data to a off-chip master device.\n", TEST_COUNT);
    

  56.     printf("In the meanwhile the SPI controller will receive %d data from the off-chip master device.\n", TEST_COUNT);
    

  57.     printf("After the transfer is done, the %d received data will be printed out.\n", TEST_COUNT);
    


  58. 

  59.     for(u32TxDataCount = 0; u32TxDataCount < TEST_COUNT; u32TxDataCount++)
    

  60.     {
    

  61.         /* Write the initial value to source buffer */
    

  62.         u32Tmp = u32TxDataCount;
    

  63.         g_au32SourceData[u32TxDataCount] = 0x00AA0000 + u32Tmp;
    

  64.         /* Clear destination buffer */
    

  65.         g_au32DestinationData[u32TxDataCount] = 0;
    

  66.     }
    


  67. 

  68.     u32TxDataCount = 0;
    

  69.     u32RxDataCount = 0;
    

  70.                 SPI_ENABLE(SPI1);
    

  71.     printf("Press any key if the master device configuration is ready.");
    

  72.     getchar();
    

  73.     printf("\n");
    


  74. 

  75.     /* Access TX and RX FIFO */
    

  76.     while(u32RxDataCount < TEST_COUNT)
    

  77.     {
    

  78.         /* Check TX FULL flag and TX data count */
    

  79.         if((SPI_GET_TX_FIFO_FULL_FLAG(SPI1) == 0) && (u32TxDataCount < TEST_COUNT))
    

  80.             SPI_WRITE_TX(SPI1, g_au32SourceData[u32TxDataCount++]); /* Write to TX FIFO */
    

  81.         /* Check RX EMPTY flag */
    

  82.         if(SPI_GET_RX_FIFO_EMPTY_FLAG(SPI1) == 0)
    

  83.         {
    

  84.             u32Tmp = u32RxDataCount;
    

  85.             g_au32DestinationData[u32Tmp++] = SPI_READ_RX(SPI1); /* Read RX FIFO */
    

  86.             u32RxDataCount = u32Tmp;
    

  87.         }
    

  88.     }
    


  89. 

  90.     /* Print the received data */
    

  91.     printf("Received data:\n");
    

  92.     for(u32RxDataCount = 0; u32RxDataCount < TEST_COUNT; u32RxDataCount++)
    

  93.     {
    

  94.         u32Tmp = u32RxDataCount;
    

  95.         printf("%d:\t0x%X\n", u32RxDataCount, g_au32DestinationData[u32Tmp]);
    

  96.     }
    

  97.     printf("The data transfer was done.\n");
    


  98. 

  99.     printf("\n\nExit SPI driver sample code.\n");
    


  100. 

  101.     /* Disable SPI1 peripheral clock */
    

  102.     SPI_Close(SPI1);
    

  103.     while(1);
    

  104. }
    


  105. 

  106. void SYS_Init(void)
    

  107. {
    


  108. 

  109. /*---------------------------------------------------------------------------------------------------------*/
    

  110. /* Init System Clock                                                                                       */
    

  111. /*---------------------------------------------------------------------------------------------------------*/
    

  112.     /* Unlock protected registers */
    

  113.     //SYS_UnlockReg();
    

  114.      
    

  115.     /* Enable  XTAL */
    

  116.     CLK->PWRCTL |= CLK_PWRCTL_HXTEN_Msk;
    


  117. 

  118.     CLK_SetCoreClock(FREQ_96MHZ);
    

  119.     
    

  120.                 /* PCLK divider */
    

  121.                 CLK_SetModuleClock(PCLK_MODULE, NULL, 1);
    

  122.                 
    

  123.     /* Lock protected registers */
    

  124.     //SYS_LockReg();
    

  125.         
    

  126. }
    


  127. 

  128. void UART0_Init(void)
    

  129. {
    

  130.                 /* Enable UART0 Module clock */
    

  131.     CLK_EnableModuleClock(UART0_MODULE);
    

  132.                 /* UART0 module clock from EXT */
    

  133.                 CLK_SetModuleClock(UART0_MODULE, CLK_UART0_SRC_EXT, 0);
    

  134.     /* Reset IP */
    

  135.     SYS_ResetModule(UART0_RST);    
    

  136.     /* Configure UART0 and set UART0 Baud-rate */
    

  137.                 UART_Open(UART0, 115200);
    

  138.                 /*---------------------------------------------------------------------------------------------------------*/
    

  139.     /* Init I/O Multi-function                                                                                 */
    

  140.     /*---------------------------------------------------------------------------------------------------------*/
    

  141.     /* Configure multi-function pins for UART0 RXD and TXD */
    

  142.                 SYS->GPB_MFPL  = (SYS->GPB_MFPL & (~SYS_GPB_MFPL_PB0MFP_Msk) ) | SYS_GPB_MFPL_PB0MFP_UART0_TXD;        
    

  143.                 SYS->GPB_MFPL  = (SYS->GPB_MFPL & (~SYS_GPB_MFPL_PB1MFP_Msk) ) | SYS_GPB_MFPL_PB1MFP_UART0_RXD;        
    

  144.         
    

  145. }
    


  146. 

  147. void SPI1_Init(void)
    

  148. {
    

  149.                 /* Enable SPI1 Module clock */
    

  150.     CLK_EnableModuleClock(SPI1_MODULE);
    

  151.                 /* SPI1 module clock from EXT */
    

  152.                 CLK_SetModuleClock(SPI1_MODULE, CLK_SPI1_SRC_PLL, 0);
    

  153.     /* Reset IP */
    

  154.     SYS_ResetModule(SPI1_RST);    
    

  155.     /*---------------------------------------------------------------------------------------------------------*/
    

  156.     /* Init I/O Multi-function                                                                                 */
    

  157.     /*---------------------------------------------------------------------------------------------------------*/
    

  158.     /* Configure multi-function pins for SPI1 */
    

  159.                 SYS->GPB_MFPH  = (SYS->GPB_MFPH & (~SYS_GPB_MFPH_PB10MFP_Msk) ) | SYS_GPB_MFPH_PB10MFP_SPI1_SS;        
    

  160.                 SYS->GPB_MFPH  = (SYS->GPB_MFPH & (~SYS_GPB_MFPH_PB11MFP_Msk) ) | SYS_GPB_MFPH_PB11MFP_SPI1_CLK;        
    

  161.                 SYS->GPB_MFPH  = (SYS->GPB_MFPH & (~SYS_GPB_MFPH_PB12MFP_Msk) ) | SYS_GPB_MFPH_PB12MFP_SPI1_MOSI;        
    

  162.                 SYS->GPB_MFPH  = (SYS->GPB_MFPH & (~SYS_GPB_MFPH_PB13MFP_Msk) ) | SYS_GPB_MFPH_PB13MFP_SPI1_MISO;        
    


  163. 

  164.                 /*---------------------------------------------------------------------------------------------------------*/
    

  165.     /* Init SPI                                                                                                */
    

  166.     /*---------------------------------------------------------------------------------------------------------*/
    

  167.     /* Configure SPI1 as a slave, clock idle low, 32-bit transaction, drive output on falling clock edge and latch input on rising edge. */
    

  168.     /* Configure SPI1 as a low level active device. SPI peripheral clock rate = f_PCLK0 */
    

  169.     SPI_Open(SPI1, SPI_SLAVE, SPI_MODE_0, 32, NULL);
    

  170. }
    


  171. 

  172. /*** (C) COPYRIGHT 2015 Nuvoton Technology Corp. ***/
    


  173.
回复

收藏 举报

xixi2017 发表于 2017-5-16 22:03 | 显示全部楼层
看了官方的手册和例程，完全可以当普通的用。
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

subo19920716

2

主题

6

帖子

1

粉丝
快速回复 在线客服 返回列表 返回顶部
0