21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › 标准SPI，Dual SPI和Qual SPI
返回列表 发新帖我要提问

[牛人杂谈] 标准SPI，Dual SPI和Qual SPI

[复制链接]
2028|9
 楼主| zhuomuniao110 发表于 2018-12-26 23:42 | 显示全部楼层 |阅读模式
spi, flash, SPIFLASH, IO, MOS

1. 标准SPI

标准SPI通常就称SPI，它是一种串行外设接口规范，有4根引脚信号：clk , cs, mosi, miso

2. Dual SPI

它只是针对SPI Flash而言，不是针对所有SPI外设。对于SPI Flash，全双工并不常用，因此扩展了mosi和miso的用法，让它们工作在半双工，用以加倍数据传输。也就是对于Dual SPI Flash，可以发送一个命令字节进入dual mode，这样mosi变成SIO0（serial io 0），mosi变成SIO1（serial io 1）,这样一个时钟周期内就能传输2个bit数据，加倍了数据传输

3. Qual SPI

与Dual SPI类似，也是针对SPI Flash，Qual SPI Flash增加了两根I/O线（SIO2,SIO3），目的是一个时钟内传输4个bit

所以对于SPI Flash，有标准spi flash，dual spi , qual spi 三种类型，分别对应3-wire, 4-wire, 6-wire，在相同clock下，线数越多，传输速率越高。

btw：spi flash一般为NOR Flash


回复

收藏 举报

相关帖子
 楼主| zhuomuniao110 发表于 2018-12-26 23:43 | 显示全部楼层
复制
  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: 6 $
    

  5.  * $Date: 14/08/05 11:13a $
    

  6.  * @brief
    

  7.  *           Demonstrate how to communicate with an off-chip SPI slave device with Dual I/O mode and FIFO mode.
    

  8.  *           This sample code needs to work with SPI_SlaveDualIOMode sample code.
    

  9.  * @note
    

  10.  * Copyright (C) 2014 Nuvoton Technology Corp. All rights reserved.
    

  11.  *
    

  12.  ******************************************************************************/
    

  13. #include <stdio.h>
    

  14. #include "NUC123.h"
    


  15. 


  16. 

  17. #define TEST_COUNT 16
    


  18. 

  19. uint32_t g_au32SourceData[TEST_COUNT];
    

  20. uint32_t g_au32DestinationData[TEST_COUNT];
    

  21. volatile uint32_t g_u32TxDataCount;
    

  22. volatile uint32_t g_u32RxDataCount;
    


  23. 

  24. /* Function prototype declaration */
    

  25. void SYS_Init(void);
    

  26. void SPI_Init(void);
    


  27. 

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

  29. /* Main function */
    

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

  31. int main(void)
    

  32. {
    

  33.     uint32_t u32DataCount;
    


  34. 

  35.     /* Unlock protected registers */
    

  36.     SYS_UnlockReg();
    


  37. 

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

  39.     SYS_Init();
    


  40. 

  41.     /* Lock protected registers */
    

  42.     SYS_LockReg();
    


  43. 

  44.     /* Configure UART0: 115200, 8-bit word, no parity bit, 1 stop bit. */
    

  45.     UART_Open(UART0, 115200);
    


  46. 

  47.     /* Init SPI */
    

  48.     SPI_Init();
    


  49. 

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

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

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

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

  54.     printf("\n");
    

  55.     printf("Configure SPI0 as a master.\n");
    

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

  57.     printf("The I/O connection for SPI0:\n");
    

  58.     printf("    SPI0_SS0 (PC.0)\n    SPI0_CLK (PC.1)\n");
    

  59.     printf("    SPI0_MISO0 (PC.2)\n    SPI0_MOSI0 (PC.3)\n\n");
    

  60.     printf("SPI controller will enable Dual I/O mode and FIFO mode, then transfer %d data to a off-chip slave device.\n", TEST_COUNT);
    

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

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

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


  64. 

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

  66.     {
    

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

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

  69.         /* Clear destination buffer */
    

  70.         g_au32DestinationData[u32DataCount] = 0;
    

  71.     }
    


  72. 

  73.     printf("Before starting the data transfer, make sure the slave device is ready.\n");
    

  74.     printf("Press any key to start the Dual I/O output transfer.");
    

  75.     getchar();
    

  76.     printf("\n");
    


  77. 

  78.     /* Enable Dual I/O output mode */
    

  79.     SPI_ENABLE_DUAL_OUTPUT_MODE(SPI0);
    

  80.     /* Enable FIFO mode, set TX FIFO threshold, enable TX FIFO threshold interrupt and RX FIFO time-out interrupt */
    

  81.     SPI_EnableFIFO(SPI0, 2, 2);
    

  82.     SPI_EnableInt(SPI0, SPI_FIFO_TX_INT_MASK | SPI_FIFO_TIMEOUT_INT_MASK);
    

  83.     g_u32TxDataCount = 0;
    

  84.     g_u32RxDataCount = 0;
    

  85.     NVIC_EnableIRQ(SPI0_IRQn);
    


  86. 

  87.     /* Wait for transfer done */
    

  88.     while(g_u32RxDataCount < TEST_COUNT);
    


  89. 

  90.     /* Enable Dual I/O input mode */
    

  91.     SPI_ENABLE_DUAL_INPUT_MODE(SPI0);
    

  92.     printf("Dual I/O output transfer is done. Before starting the Dual I/O input transfer, make sure the slave device is ready.\n");
    

  93.     printf("Press any key to start the Dual I/O input transfer.");
    

  94.     getchar();
    

  95.     printf("\n");
    

  96.     
    

  97.     g_u32TxDataCount = 0;
    

  98.     g_u32RxDataCount = 0;
    

  99.     SPI_EnableInt(SPI0, SPI_FIFO_TX_INT_MASK | SPI_FIFO_TIMEOUT_INT_MASK);
    

  100.     
    

  101.     /* Wait for transfer done */
    

  102.     while(g_u32RxDataCount < TEST_COUNT);
    

  103.     
    

  104.     /* Print the received data */
    

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

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

  107.     {
    

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

  109.     }
    

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

  111.     SPI_DisableInt(SPI0, SPI_FIFO_TX_INT_MASK | SPI_FIFO_TIMEOUT_INT_MASK);
    

  112.     NVIC_DisableIRQ(SPI0_IRQn);
    

  113.     
    

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


  115. 

  116.     /* Disable SPI0 peripheral clock */
    

  117.     SPI_Close(SPI0);
    

  118.     while(1);
    

  119. }
    


  120. 

  121. void SYS_Init(void)
    

  122. {
    

  123.     /*---------------------------------------------------------------------------------------------------------*/
    

  124.     /* Init System Clock                                                                                       */
    

  125.     /*---------------------------------------------------------------------------------------------------------*/
    


  126. 

  127.     /* Enable XT1_OUT (PF0) and XT1_IN (PF1) */
    

  128.     SYS->GPF_MFP |= SYS_GPF_MFP_PF0_XT1_OUT | SYS_GPF_MFP_PF1_XT1_IN;
    


  129. 

  130.     /* Enable external 12MHz XTAL */
    

  131.     CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);
    


  132. 

  133.     /* Waiting for clock ready */
    

  134.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);
    


  135. 

  136.     /* Switch HCLK clock source to HXT and HCLK source divide 1 */
    

  137.     CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HXT, CLK_CLKDIV_HCLK(1));
    


  138. 

  139.     /* Select HXT as the clock source of UART0 */
    

  140.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));
    


  141. 

  142.     /* Select HCLK as the clock source of SPI0 */
    

  143.     CLK_SetModuleClock(SPI0_MODULE, CLK_CLKSEL1_SPI0_S_HCLK, MODULE_NoMsk);
    


  144. 

  145.     /* Enable UART peripheral clock */
    

  146.     CLK_EnableModuleClock(UART0_MODULE);
    

  147.     /* Enable SPI0 peripheral clock */
    

  148.     CLK_EnableModuleClock(SPI0_MODULE);
    


  149. 

  150.     /* Update System Core Clock */
    

  151.     /* User can use SystemCoreClockUpdate() to calculate PllClock, SystemCoreClock and CyclesPerUs automatically. */
    

  152.     SystemCoreClockUpdate();
    


  153. 

  154.     /*---------------------------------------------------------------------------------------------------------*/
    

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

  156.     /*---------------------------------------------------------------------------------------------------------*/
    

  157.     /* Set PB multi-function pins for UART0 RXD and TXD */
    

  158.     SYS->GPB_MFP = SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD;
    


  159. 

  160.     /* Setup SPI0 multi-function pins */
    

  161.     SYS->GPC_MFP = SYS_GPC_MFP_PC0_SPI0_SS0 | SYS_GPC_MFP_PC1_SPI0_CLK | SYS_GPC_MFP_PC2_SPI0_MISO0 | SYS_GPC_MFP_PC3_SPI0_MOSI0;
    

  162.     SYS->ALT_MFP = SYS_ALT_MFP_PC0_SPI0_SS0 | SYS_ALT_MFP_PC1_SPI0_CLK | SYS_ALT_MFP_PC2_SPI0_MISO0 | SYS_ALT_MFP_PC3_SPI0_MOSI0;
    

  163. }
    


  164. 

  165. void SPI_Init(void)
    

  166. {
    

  167.     /*---------------------------------------------------------------------------------------------------------*/
    

  168.     /* Init SPI                                                                                                */
    

  169.     /*---------------------------------------------------------------------------------------------------------*/
    

  170.     /* Configure SPI0 as a master, clock idle low, 32-bit transaction, drive output on falling clock edge and latch input on rising edge. */
    

  171.     /* Set IP clock divider. SPI clock rate = 2 MHz */
    

  172.     SPI_Open(SPI0, SPI_MASTER, SPI_MODE_0, 32, 2000000);
    


  173. 

  174.     /* Enable the automatic hardware slave select function. Select the SPI0_SS0 pin and configure as low-active. */
    

  175.     SPI_EnableAutoSS(SPI0, SPI_SS0, SPI_SS_ACTIVE_LOW);
    

  176. }
    


  177. 

  178. void SPI0_IRQHandler(void)
    

  179. {
    

  180.     /* Check RX EMPTY flag */
    

  181.     while(SPI_GET_RX_FIFO_EMPTY_FLAG(SPI0) == 0)
    

  182.     {
    

  183.         /* Read RX FIFO */
    

  184.         g_au32DestinationData[g_u32RxDataCount++] = SPI_READ_RX0(SPI0);
    

  185.     }
    

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

  187.     while((SPI_GET_TX_FIFO_FULL_FLAG(SPI0) == 0) && (g_u32TxDataCount < TEST_COUNT))
    

  188.     {
    

  189.         /* Write to TX FIFO */
    

  190.         SPI_WRITE_TX0(SPI0, g_au32SourceData[g_u32TxDataCount++]);
    

  191.     }
    

  192.     if(g_u32TxDataCount >= TEST_COUNT)
    

  193.         SPI_DisableInt(SPI0, SPI_FIFO_TX_INT_MASK); /* Disable TX FIFO threshold interrupt */
    


  194. 

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

  196.     if(SPI_GetIntFlag(SPI0, SPI_FIFO_TIMEOUT_INT_MASK))
    

  197.     {
    

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

  199.         while(SPI_GET_RX_FIFO_EMPTY_FLAG(SPI0) == 0)
    

  200.             g_au32DestinationData[g_u32RxDataCount++] = SPI_READ_RX0(SPI0);
    

  201.     }
    

  202. }
    


  203. 


  204. 

  205. /*** (C) COPYRIGHT 2014 Nuvoton Technology Corp. ***/
    


  206.
回复

收藏 举报

 楼主| zhuomuniao110 发表于 2018-12-26 23:43 | 显示全部楼层
复制
  1. /**************************************************************************//**
    

  2.  * @file     main.c
    

  3.  * @version  V2.0
    

  4.  * $Revision: 6 $
    

  5.  * $Date: 14/08/05 11:13a $
    

  6.  * @brief
    

  7.  *           Demonstrate how to communicate with an off-chip SPI master device with Dual I/O mode and FIFO mode.
    

  8.  *           This sample code needs to work with SPI_MasterDualIOMode sample code.
    

  9.  * @note
    

  10.  * Copyright (C) 2014 Nuvoton Technology Corp. All rights reserved.
    

  11.  *
    

  12.  ******************************************************************************/
    

  13. #include <stdio.h>
    

  14. #include "NUC123.h"
    


  15. 


  16. 

  17. #define TEST_COUNT 16
    


  18. 

  19. uint32_t g_au32SourceData[TEST_COUNT];
    

  20. uint32_t g_au32DestinationData[TEST_COUNT];
    

  21. volatile uint32_t g_u32TxDataCount;
    

  22. volatile uint32_t g_u32RxDataCount;
    


  23. 

  24. /* Function prototype declaration */
    

  25. void SYS_Init(void);
    

  26. void SPI_Init(void);
    


  27. 

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

  29. /* Main function */
    

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

  31. int main(void)
    

  32. {
    

  33.     volatile uint32_t u32TxDataCount, u32RxDataCount;
    


  34. 

  35.     /* Unlock protected registers */
    

  36.     SYS_UnlockReg();
    


  37. 

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

  39.     SYS_Init();
    


  40. 

  41.     /* Lock protected registers */
    

  42.     SYS_LockReg();
    


  43. 

  44.     /* Configure UART0: 115200, 8-bit word, no parity bit, 1 stop bit. */
    

  45.     UART_Open(UART0, 115200);
    


  46. 

  47.     /* Init SPI */
    

  48.     SPI_Init();
    

  49.     /* Enable Dual I/O input mode */
    

  50.     SPI_ENABLE_DUAL_INPUT_MODE(SPI0);
    

  51.     /* Enable FIFO mode and set FIFO threshold. */
    

  52.     SPI_EnableFIFO(SPI0, 2, 2);
    


  53. 

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

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

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

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

  58.     printf("\n");
    

  59.     printf("Configure SPI0 as a slave.\n");
    

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

  61.     printf("The I/O connection for SPI0:\n");
    

  62.     printf("    SPI0_SS0 (PC.0)\n    SPI0_CLK (PC.1)\n");
    

  63.     printf("    SPI0_MISO0 (PC.2)\n    SPI0_MOSI0 (PC.3)\n\n");
    

  64.     printf("SPI controller will enable Dual I/O mode and FIFO mode.\n");
    

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

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

  67.     printf("In the second stage, the SPI controller will transfer %d data to the off-chip master device.\n", TEST_COUNT);
    

  68.     
    

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

  70.     {
    

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

  72.         g_au32SourceData[u32TxDataCount] = 0x00AA0000 + u32TxDataCount;
    

  73.         /* Clear destination buffer */
    

  74.         g_au32DestinationData[u32TxDataCount] = 0;
    

  75.     }
    


  76. 

  77.     u32RxDataCount = 0;
    

  78.     printf("< Stage 1 >\n");
    

  79.     printf("Press any key to start the Dual I/O input transfer if the master device configuration is ready.");
    

  80.     getchar();
    

  81.     printf("\n");
    


  82. 

  83.     /* Access RX FIFO */
    

  84.     while(u32RxDataCount < TEST_COUNT)
    

  85.     {
    

  86.         /* Check RX EMPTY flag */
    

  87.         if(SPI_GET_RX_FIFO_EMPTY_FLAG(SPI0) == 0)
    

  88.             g_au32DestinationData[u32RxDataCount++] = SPI_READ_RX0(SPI0); /* Read RX FIFO */
    

  89.     }
    


  90. 

  91.     /* Print the received data */
    

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

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

  94.     {
    

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

  96.     }
    


  97. 

  98.     /* Enable Dual I/O output mode */
    

  99.     SPI_ENABLE_DUAL_OUTPUT_MODE(SPI0);
    

  100.     u32TxDataCount = 0;
    

  101.     u32RxDataCount = 0;
    

  102.     printf("< Stage 2 >\n");
    

  103.     printf("Enable Dual I/O output mode. Slave is ready to transfer.\n");
    

  104.     
    

  105.     /* Access TX and RX FIFO */
    

  106.     while(u32RxDataCount < TEST_COUNT)
    

  107.     {
    

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

  109.         if((SPI_GET_TX_FIFO_FULL_FLAG(SPI0) == 0) && (u32TxDataCount < TEST_COUNT))
    

  110.             SPI_WRITE_TX0(SPI0, g_au32SourceData[u32TxDataCount++]); /* Write to TX FIFO */
    

  111.         /* Check RX EMPTY flag */
    

  112.         if(SPI_GET_RX_FIFO_EMPTY_FLAG(SPI0) == 0)
    

  113.             g_au32DestinationData[u32RxDataCount++] = SPI_READ_RX0(SPI0); /* Read RX FIFO */
    

  114.     }
    

  115.     
    

  116.     
    

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


  118. 

  119.     /* Disable SPI0 peripheral clock */
    

  120.     SPI_Close(SPI0);
    

  121.     while(1);
    

  122. }
    


  123. 

  124. void SYS_Init(void)
    

  125. {
    

  126.     /*---------------------------------------------------------------------------------------------------------*/
    

  127.     /* Init System Clock                                                                                       */
    

  128.     /*---------------------------------------------------------------------------------------------------------*/
    


  129. 

  130.     /* Enable XT1_OUT (PF0) and XT1_IN (PF1) */
    

  131.     SYS->GPF_MFP |= SYS_GPF_MFP_PF0_XT1_OUT | SYS_GPF_MFP_PF1_XT1_IN;
    


  132. 

  133.     /* Enable external 12 MHz XTAL */
    

  134.     CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);
    


  135. 

  136.     /* Waiting for clock ready */
    

  137.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);
    


  138. 

  139.     /* Switch HCLK clock source to HXT and HCLK source divide 1 */
    

  140.     CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HXT, CLK_CLKDIV_HCLK(1));
    


  141. 

  142.     /* Select HXT as the clock source of UART0 */
    

  143.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));
    


  144. 

  145.     /* Select HCLK as the clock source of SPI0 */
    

  146.     CLK_SetModuleClock(SPI0_MODULE, CLK_CLKSEL1_SPI0_S_HCLK, MODULE_NoMsk);
    


  147. 

  148.     /* Enable UART peripheral clock */
    

  149.     CLK_EnableModuleClock(UART0_MODULE);
    

  150.     /* Enable SPI0 peripheral clock */
    

  151.     CLK_EnableModuleClock(SPI0_MODULE);
    


  152. 

  153.     /* Update System Core Clock */
    

  154.     /* User can use SystemCoreClockUpdate() to calculate PllClock, SystemCoreClock and CyclesPerUs automatically. */
    

  155.     SystemCoreClockUpdate();
    


  156. 

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

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

  159.     /*---------------------------------------------------------------------------------------------------------*/
    

  160.     /* Set PB multi-function pins for UART0 RXD and TXD */
    

  161.     SYS->GPB_MFP = SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD;
    


  162. 

  163.     /* Setup SPI0 multi-function pins */
    

  164.     SYS->GPC_MFP = SYS_GPC_MFP_PC0_SPI0_SS0 | SYS_GPC_MFP_PC1_SPI0_CLK | SYS_GPC_MFP_PC2_SPI0_MISO0 | SYS_GPC_MFP_PC3_SPI0_MOSI0;
    

  165.     SYS->ALT_MFP = SYS_ALT_MFP_PC0_SPI0_SS0 | SYS_ALT_MFP_PC1_SPI0_CLK | SYS_ALT_MFP_PC2_SPI0_MISO0 | SYS_ALT_MFP_PC3_SPI0_MOSI0;
    

  166. }
    


  167. 

  168. void SPI_Init(void)
    

  169. {
    

  170.     /*---------------------------------------------------------------------------------------------------------*/
    

  171.     /* Init SPI                                                                                                */
    

  172.     /*---------------------------------------------------------------------------------------------------------*/
    

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

  174.     /* Configure SPI0 as a low level active device. SPI peripheral clock rate is equal to system clock rate. */
    

  175.     SPI_Open(SPI0, SPI_SLAVE, SPI_MODE_0, 32, NULL);
    

  176. }
    


  177. 

  178. /*** (C) COPYRIGHT 2014 Nuvoton Technology Corp. ***/
    


  179. 


  180.
回复

收藏 举报

dongliushui 发表于 2018-12-27 11:39 | 显示全部楼层
只用过标准的SPI
回复

收藏 举报

幸福小强 发表于 2018-12-27 23:16 | 显示全部楼层
手册好像提过。
回复

收藏 举报

598330983 发表于 2018-12-29 23:32 来自手机 | 显示全部楼层
spi好几个形势
回复

收藏 举报

xinpian101 发表于 2018-12-30 13:43 | 显示全部楼层
新唐的单片机性能强大，支持多种SPI模式。
回复

收藏 举报

观海 发表于 2019-1-8 11:12 | 显示全部楼层
我很少用全双工的
回复

收藏 举报

keaibukelian 发表于 2019-1-8 11:31 | 显示全部楼层
非常感谢楼主分享
回复

收藏 举报

renzheshengui 发表于 2019-1-8 11:51 | 显示全部楼层
我用三根线的时候很多
回复

收藏 举报

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

本版积分规则

zhuomuniao110

233

主题

3529

帖子

11

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