API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 29th, 2016
176
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 16.33 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  * IL9341.c - interface routines for IL9341 LCD.
  3.  * shamelessly ganked from Adafruit_IL9341 library
  4.  * 03-11-16 E. Brombaugh
  5.  */
  6.  
  7. #include "il9341.h"
  8. #include "cyclesleep.h"
  9.  
  10. /* ----------------------- I/O definitions ----------------------- */
  11. #define IL9341_CS_GPIO_CLK_ENABLE() __HAL_RCC_GPIOB_CLK_ENABLE()
  12. #define IL9341_CS_GPIO_PORT GPIOB
  13. #define IL9341_CS_PIN GPIO_PIN_10
  14.  
  15. #define IL9341_DC_GPIO_CLK_ENABLE() __HAL_RCC_GPIOE_CLK_ENABLE()
  16. #define IL9341_DC_GPIO_PORT GPIOE
  17. #define IL9341_DC_PIN GPIO_PIN_13
  18.  
  19. #define IL9341_RST_GPIO_CLK_ENABLE() __HAL_RCC_GPIOB_CLK_ENABLE()
  20. #define IL9341_RST_GPIO_PORT GPIOB
  21. #define IL9341_RST_PIN GPIO_PIN_11
  22.  
  23. /* diag is not hooked up on AD-AB-04 */
  24. #define IL9341_DIAG_GPIO_CLK_ENABLE()
  25. #define IL9341_DIAG_GPIO_PORT
  26. #define IL9341_DIAG_PIN
  27.  
  28. #define IL9341_MOSI_GPIO_CLK_ENABLE() __HAL_RCC_GPIOE_CLK_ENABLE()
  29. #define IL9341_MOSI_GPIO_PORT GPIOE
  30. #define IL9341_MOSI_PIN GPIO_PIN_14
  31. #define IL9341_MOSI_AF GPIO_AF5_SPI4
  32.  
  33. #define IL9341_SCLK_GPIO_CLK_ENABLE() __HAL_RCC_GPIOE_CLK_ENABLE()
  34. #define IL9341_SCLK_GPIO_PORT GPIOE
  35. #define IL9341_SCLK_PIN GPIO_PIN_12
  36. #define IL9341_SCLK_AF GPIO_AF5_SPI4
  37.  
  38. #define IL9341_SPI_CLK_ENABLE() __HAL_RCC_SPI4_CLK_ENABLE()
  39. #define IL9341_SPI_PORT SPI4
  40.  
  41. #define IL9341_SPI_DMA_CLK_ENABLE() __HAL_RCC_DMA2_CLK_ENABLE();
  42. #define IL9341_SPI_DMA_STREAM DMA2_Stream1
  43. #define IL9341_SPI_DMA_CHANNEL DMA_CHANNEL_4
  44. #define IL9341_SPI_DMA_TX_IRQn DMA2_Stream1_IRQn
  45. #define IL9341_SPI_DMA_TX_IRQHandler DMA2_Stream1_IRQHandler
  46. #define IL9341_SPI_DMA_TCFLAG DMA_FLAG_TCIF1_5
  47.  
  48. #define IL9341_CS_LOW()    HAL_GPIO_WritePin(IL9341_CS_GPIO_PORT, IL9341_CS_PIN, GPIO_PIN_RESET)
  49. #define IL9341_CS_HIGH()   HAL_GPIO_WritePin(IL9341_CS_GPIO_PORT, IL9341_CS_PIN, GPIO_PIN_SET)
  50. #define IL9341_DC_CMD()    HAL_GPIO_WritePin(IL9341_DC_GPIO_PORT, IL9341_DC_PIN, GPIO_PIN_RESET)
  51. #define IL9341_DC_DATA()   HAL_GPIO_WritePin(IL9341_DC_GPIO_PORT, IL9341_DC_PIN, GPIO_PIN_SET)
  52. #define IL9341_RST_LOW()   HAL_GPIO_WritePin(IL9341_RST_GPIO_PORT, IL9341_RST_PIN, GPIO_PIN_RESET)
  53. #define IL9341_RST_HIGH()  HAL_GPIO_WritePin(IL9341_RST_GPIO_PORT, IL9341_RST_PIN, GPIO_PIN_SET)
  54.  
  55. #if 0
  56. #define IL9341_DIAG_LOW()  HAL_GPIO_WritePin(IL9341_DIAG_GPIO_PORT, IL9341_DIAG_PIN, GPIO_PIN_RESET)
  57. #define IL9341_DIAG_HIGH() HAL_GPIO_WritePin(IL9341_DIAG_GPIO_PORT, IL9341_DIAG_PIN, GPIO_PIN_SET)
  58. #else
  59. #define IL9341_DIAG_LOW()
  60. #define IL9341_DIAG_HIGH()
  61. #endif
  62.  
  63. // some flags for initR() :(
  64. #define INITR_GREENTAB 0x0
  65. #define INITR_REDTAB   0x1
  66.  
  67. #define IL9341_TFTWIDTH  240
  68. #define IL9341_TFTHEIGHT 320
  69.  
  70. #define IL9341_NOP     0x00
  71. #define IL9341_SWRESET 0x01
  72. #define IL9341_RDDID   0x04
  73. #define IL9341_RDDST   0x09
  74.  
  75. #define IL9341_SLPIN   0x10
  76. #define IL9341_SLPOUT  0x11
  77. #define IL9341_PTLON   0x12
  78. #define IL9341_NORON   0x13
  79.  
  80. #define IL9341_INVOFF  0x20
  81. #define IL9341_INVON   0x21
  82. #define IL9341_GAMMASET 0x26
  83. #define IL9341_DISPOFF 0x28
  84. #define IL9341_DISPON  0x29
  85. #define IL9341_CASET   0x2A
  86. #define IL9341_RASET   0x2B
  87. #define IL9341_RAMWR   0x2C
  88. #define IL9341_RAMRD   0x2E
  89.  
  90. #define IL9341_PTLAR   0x30
  91. #define IL9341_PIXFMT  0x3A
  92. #define IL9341_MADCTL  0x36
  93.  
  94. #define IL9341_FRMCTR1 0xB1
  95. #define IL9341_FRMCTR2 0xB2
  96. #define IL9341_FRMCTR3 0xB3
  97. #define IL9341_INVCTR  0xB4
  98. #define IL9341_DFUNCTR 0xB6
  99.  
  100. #define IL9341_PWCTR1  0xC0
  101. #define IL9341_PWCTR2  0xC1
  102. #define IL9341_PWCTR3  0xC2
  103. #define IL9341_PWCTR4  0xC3
  104. #define IL9341_PWCTR5  0xC4
  105. #define IL9341_VMCTR1  0xC5
  106. #define IL9341_VMCTR2  0xC7
  107.  
  108. #define IL9341_RDID1   0xDA
  109. #define IL9341_RDID2   0xDB
  110. #define IL9341_RDID3   0xDC
  111. #define IL9341_RDID4   0xDD
  112.  
  113. #define IL9341_PWCTR6  0xFC
  114.  
  115. #define IL9341_GMCTRP1 0xE0
  116. #define IL9341_GMCTRN1 0xE1
  117.  
  118. /* uncomment this to use DMA */
  119. #define IL9341_USE_DMA
  120.  
  121. /* ----------------------- private variables ----------------------- */
  122. /* 320x240 IL9341 specific sequence */
  123. const static uint16_t initlst[] = {
  124.     0xEF | IL9341_CMD,           // Unknown magic!
  125.     0x03, 0x80, 0x02,
  126.     0xCF | IL9341_CMD,           // Power control B
  127.     0x00, 0x83, 0x30,
  128.     0xED | IL9341_CMD,           // Power on sequence control
  129.     0x64, 0x03, 0x12, 0x81,
  130.     0xE8 | IL9341_CMD,           // Driver timing control A
  131.     0x85, 0x01, 0x79,
  132.     0xCB | IL9341_CMD,           // Power control B
  133.     0x39, 0x2C, 0x00, 0x34, 0x02,
  134.     0xF7 | IL9341_CMD,           // Pump ratio control
  135.     0x20,
  136.     0xEA | IL9341_CMD,           // Driver timing control B
  137.     0x00, 0x00,
  138.     IL9341_PWCTR1 | IL9341_CMD,  // Power control 1
  139.     0x23,
  140.     IL9341_PWCTR2 | IL9341_CMD,  // Power control 2
  141.     0x10,
  142.     IL9341_VMCTR1 | IL9341_CMD,  // VCOM Control 1
  143.     0x35, 0x3E,
  144.     IL9341_VMCTR2 | IL9341_CMD,  // VCOM Control 2
  145.     0xBE,
  146.     IL9341_MADCTL | IL9341_CMD,  // Memory Access Control
  147.     0x48,
  148.     IL9341_PIXFMT | IL9341_CMD,  //
  149.     0x55,
  150.     IL9341_FRMCTR1| IL9341_CMD,  //
  151.     0x00, 0x18,
  152.     IL9341_DFUNCTR| IL9341_CMD,  //
  153.     0x08, 0x82, 0x27,
  154.     0xF2| IL9341_CMD,            // 3Gamma Function Disable
  155.     0x00,
  156.     IL9341_GAMMASET| IL9341_CMD, // Set Gamma
  157.     0x01,
  158.     IL9341_GMCTRP1| IL9341_CMD,  // Gamma
  159.     0x1F, 0x1A, 0x18, 0x0A,
  160.     0x0F, 0x06, 0x45, 0x87,
  161.     0x32, 0x0A, 0x07, 0x02,
  162.     0x07, 0x05, 0x00,
  163.     IL9341_GMCTRN1 | IL9341_CMD, // Gamma
  164.     0x00, 0x25, 0x27, 0x05,
  165.     0x10, 0x09, 0x3A, 0x78,
  166.     0x4D, 0x05, 0x18, 0x0D,
  167.     0x38, 0x3A, 0x1F,
  168.     IL9341_SLPOUT | IL9341_CMD,  // Exit Sleep
  169.     50 | IL9341_DLY,             //   50 ms delay
  170.     IL9341_DISPON | IL9341_CMD,  // display on
  171.     10 | IL9341_DLY,             //   10 ms delay
  172.     IL9341_END                   // END
  173. };
  174.  
  175. /* SPI port handle */
  176. SPI_HandleTypeDef SpiHandle;
  177. /* SPI lock */
  178. uint8_t il9341_spi_lock;
  179.  
  180. #ifdef IL9341_USE_DMA
  181. /* DMA channel handle */
  182. DMA_HandleTypeDef hdma_spi;
  183.  
  184. /* uncomment this for non-blocking multi-byte writes */
  185. #define IL9341_NONBLOCKING
  186. #endif
  187.  
  188. /* LCD state */
  189. uint16_t _width, _height, rotation;
  190.  
  191. /* ----------------------- Private functions ----------------------- */
  192. /**
  193.   * @brief  Custom - Transmit an amount of data in blocking mode
  194.   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains
  195.   *               the configuration information for SPI module.
  196.   * @param  pData: pointer to data buffer
  197.   * @param  Size: amount of data to be sent
  198.   * @retval none
  199.   */
  200. void IL9341_SPI_Blocking_PIO_WriteBytes(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size)
  201. {
  202.     /* Set the transaction information */
  203.     hspi->State       = HAL_SPI_STATE_BUSY_TX;
  204.     hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
  205.     hspi->pTxBuffPtr  = pData;
  206.     hspi->TxXferSize  = Size;
  207.     hspi->TxXferCount = Size;
  208.     hspi->pRxBuffPtr  = (uint8_t *)NULL;
  209.     hspi->RxXferSize  = 0;
  210.     hspi->RxXferCount = 0;
  211.  
  212.     /* send it in 16 and 8 modes for speed */
  213.     while (hspi->TxXferCount > 0)
  214.     {
  215.         if(hspi->TxXferCount != 0x1)
  216.         {
  217.             /* Wait until TXE flag is set to send data */
  218.             while(__HAL_SPI_GET_FLAG(hspi,SPI_FLAG_TXE) != SET);
  219.             hspi->Instance->DR = *((uint16_t*)hspi->pTxBuffPtr);
  220.             hspi->pTxBuffPtr += sizeof(uint16_t);
  221.             hspi->TxXferCount -= 2;
  222.         }
  223.         else
  224.         {
  225.             /* Wait until TXE flag is set to send data */
  226.             while(__HAL_SPI_GET_FLAG(hspi,SPI_FLAG_TXE) != SET);
  227.             *((__IO uint8_t*)&hspi->Instance->DR) = (*hspi->pTxBuffPtr++);
  228.             hspi->TxXferCount--;    
  229.         }
  230.     }
  231.  
  232.     /* wait for tx fifo to drain */
  233.     while((hspi->Instance->SR & SPI_FLAG_FTLVL) != SPI_FTLVL_EMPTY);
  234.  
  235.     /* wait for not busy */
  236.     while(__HAL_SPI_GET_FLAG(hspi,SPI_FLAG_BSY) != RESET);
  237.  
  238.     /* drain rx fifo */
  239.     while((hspi->Instance->SR & SPI_FLAG_FRLVL) != SPI_FRLVL_EMPTY)
  240.     {
  241.         __IO uint8_t tmpreg = *((__IO uint8_t*)&hspi->Instance->DR);
  242.         UNUSED(tmpreg); /* To avoid GCC warning */
  243.     }
  244.    
  245.     /* Clear OVERUN flag because received is not read */
  246.     __HAL_SPI_CLEAR_OVRFLAG(hspi);
  247.  
  248.     hspi->State = HAL_SPI_STATE_READY;
  249. }
  250.  
  251. #ifdef IL9341_USE_DMA
  252. /*
  253.  * Setup DMA
  254.  */
  255. void IL9341_SPI_InitDMA(void)
  256. {
  257.     // turn on DMA clock
  258.     IL9341_SPI_DMA_CLK_ENABLE();
  259.    
  260.     // Common
  261.     hdma_spi.Instance                 = IL9341_SPI_DMA_STREAM;
  262.     hdma_spi.Init.Channel             = IL9341_SPI_DMA_CHANNEL;
  263.     hdma_spi.Init.FIFOMode            = DMA_FIFOMODE_DISABLE;        
  264.     hdma_spi.Init.FIFOThreshold       = DMA_FIFO_THRESHOLD_FULL;
  265.     hdma_spi.Init.MemBurst            = DMA_MBURST_SINGLE;
  266.     hdma_spi.Init.PeriphBurst         = DMA_PBURST_SINGLE;
  267.     hdma_spi.Init.Direction           = DMA_MEMORY_TO_PERIPH;
  268.     hdma_spi.Init.PeriphInc           = DMA_PINC_DISABLE;
  269.     hdma_spi.Init.MemInc              = DMA_MINC_ENABLE;
  270.     hdma_spi.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
  271.     hdma_spi.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;
  272.     hdma_spi.Init.Mode                = DMA_NORMAL;
  273.     hdma_spi.Init.Priority            = DMA_PRIORITY_LOW;
  274.    
  275.     HAL_DMA_Init(&hdma_spi);
  276.  
  277.     /* Associate the initialized DMA handle to the the SPI handle */
  278.     __HAL_LINKDMA(&SpiHandle, hdmatx, hdma_spi);
  279.    
  280. #ifdef IL9341_NONBLOCKING
  281.     /* Enable TC IRQ */
  282.     __HAL_DMA_ENABLE_IT(&hdma_spi, DMA_IT_TC);
  283.  
  284.     /* NVIC configuration for DMA transfer complete interrupt */
  285.     HAL_NVIC_SetPriority(IL9341_SPI_DMA_TX_IRQn, 0, 0);
  286.     HAL_NVIC_EnableIRQ(IL9341_SPI_DMA_TX_IRQn);
  287. #endif
  288. }
  289.  
  290. /*
  291.  * Start DMA multi-write - used both in blocking and non-blocking
  292.  */
  293. void IL9341_SPI_start_DMA_WriteBytes(uint8_t *buffer, int32_t count)
  294. {
  295.     /* Setup buffer loc / len */
  296.     hdma_spi.Instance->NDTR = (uint32_t)count;
  297.     hdma_spi.Instance->M0AR = (uint32_t)buffer;
  298.     hdma_spi.Instance->CR  &= (uint32_t)(~DMA_SxCR_DBM);
  299.     hdma_spi.Instance->PAR  = (uint32_t)&SpiHandle.Instance->DR;
  300.  
  301.     /* Enable SPI_DMA_TX */
  302.     __HAL_DMA_ENABLE(&hdma_spi);
  303.    
  304.     /* Enable SPI DMA TX request */
  305.     SpiHandle.Instance->CR2 |= SPI_CR2_TXDMAEN;
  306. }
  307.  
  308. /*
  309.  * Finish DMA multi-write - used both in blocking and non-blocking
  310.  */
  311. void IL9341_SPI_end_DMA_WriteBytes(void)
  312. {
  313.     /* Wait until DMA count == 0 */
  314.     while(hdma_spi.Instance->NDTR != 0);
  315.    
  316.     /* wait for tx fifo to drain */
  317.     while((SpiHandle.Instance->SR & SPI_FLAG_FTLVL) != SPI_FTLVL_EMPTY);
  318.  
  319.     /* wait for not busy */
  320.     while(__HAL_SPI_GET_FLAG(&SpiHandle,SPI_FLAG_BSY) != RESET);
  321.  
  322.     /* drain rx fifo */
  323.     while((SpiHandle.Instance->SR & SPI_FLAG_FRLVL) != SPI_FRLVL_EMPTY)
  324.     {
  325.         __IO uint8_t tmpreg = *((__IO uint8_t*)&SpiHandle.Instance->DR);
  326.         UNUSED(tmpreg); /* To avoid GCC warning */
  327.     }
  328.    
  329.     /* Clear OVERUN flag because received is not read */
  330.     __HAL_SPI_CLEAR_OVRFLAG(&SpiHandle);
  331.  
  332.     /* DISABLE SPI DMA TX request */
  333.     SpiHandle.Instance->CR2 &= ~SPI_CR2_TXDMAEN;
  334.  
  335.     /* DISABLE SPI_DMA_TX */
  336.     __HAL_DMA_DISABLE(&hdma_spi);
  337.    
  338.     /* Clear DMA TransferComplete Flag */
  339.     __HAL_DMA_CLEAR_FLAG(&hdma_spi, IL9341_SPI_DMA_TCFLAG);
  340. }
  341.  
  342. #ifdef IL9341_NONBLOCKING
  343. /*
  344.  * Finish up non-blocking DMW multi-write in Interrupt Context
  345.  */
  346. void IL9341_SPI_DMA_TX_IRQHandler(void)
  347. {
  348.     /* check for IRQ */
  349. //  if(__HAL_DMA_GET_FLAG(&hdma_spi, IL9341_SPI_DMA_TCFLAG) == SET)
  350. //  {
  351.         /* finish the write */
  352.         IL9341_SPI_end_DMA_WriteBytes();
  353.  
  354.         /* de-assert CS */
  355.         IL9341_CS_HIGH();
  356.  
  357.         /* clear buffer write flag */
  358.         IL9341_DIAG_LOW();
  359.    
  360.         /* clear busy flag */
  361.         il9341_spi_lock = 0;
  362. //  }
  363. }
  364. #endif
  365. #endif
  366.  
  367. /*
  368.  * Initialize SPI interface to LCD
  369.  */
  370. void IL9341_SPI_Init(void)
  371. {
  372.     GPIO_InitTypeDef GPIO_InitStructure;
  373.  
  374.     /* Enable CS pin Clock */
  375.     IL9341_CS_GPIO_CLK_ENABLE();
  376.    
  377.     /* Enable CS pin for output */
  378.     GPIO_InitStructure.Pin =  IL9341_CS_PIN;
  379.     GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
  380.     GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
  381.     GPIO_InitStructure.Pull = GPIO_NOPULL ;
  382.     HAL_GPIO_Init(IL9341_CS_GPIO_PORT, &GPIO_InitStructure);
  383.    
  384.     /* Enable DC pin Clock */
  385.     IL9341_DC_GPIO_CLK_ENABLE();
  386.    
  387.     /* Enable DC pin for output */
  388.     GPIO_InitStructure.Pin =  IL9341_DC_PIN;
  389.     HAL_GPIO_Init(IL9341_DC_GPIO_PORT, &GPIO_InitStructure);
  390.    
  391.     /* Enable RST pin Clock */
  392.     IL9341_RST_GPIO_CLK_ENABLE();
  393.    
  394.     /* Enable RST pin for output */
  395.     GPIO_InitStructure.Pin =  IL9341_RST_PIN;
  396.     HAL_GPIO_Init(IL9341_RST_GPIO_PORT, &GPIO_InitStructure);
  397.    
  398.     /* Enable Diag pin Clock */
  399.     //IL9341_DIAG_GPIO_CLK_ENABLE();
  400.  
  401.     /* Enable Diag pin for output */
  402.     //GPIO_InitStructure.Pin =  IL9341_DIAG_PIN;
  403.     //HAL_GPIO_Init(IL9341_DIAG_GPIO_PORT, &GPIO_InitStructure);
  404.  
  405.     /* Enable MOSI pin Clock */
  406.     IL9341_MOSI_GPIO_CLK_ENABLE();
  407.    
  408.     /* Enable MOSI pin for AF output */
  409.     GPIO_InitStructure.Pin =  IL9341_MOSI_PIN;
  410.     GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
  411.     GPIO_InitStructure.Alternate = IL9341_MOSI_AF;
  412.     HAL_GPIO_Init(IL9341_MOSI_GPIO_PORT, &GPIO_InitStructure);
  413.    
  414.     /* Enable SCLK pin Clock */
  415.     IL9341_SCLK_GPIO_CLK_ENABLE();
  416.    
  417.     /* Enable SCLK pin for AF output */
  418.     GPIO_InitStructure.Pin =  IL9341_SCLK_PIN;
  419.     GPIO_InitStructure.Alternate = IL9341_SCLK_AF;
  420.     HAL_GPIO_Init(IL9341_SCLK_GPIO_PORT, &GPIO_InitStructure);
  421.    
  422.     /* Enable SPI Port Clock */
  423.     IL9341_SPI_CLK_ENABLE();
  424.    
  425.     /* Set up SPI port */
  426.     SpiHandle.Instance               = IL9341_SPI_PORT;
  427.     SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
  428.     SpiHandle.Init.Direction         = SPI_DIRECTION_2LINES;
  429.     SpiHandle.Init.CLKPhase          = SPI_PHASE_1EDGE;
  430.     SpiHandle.Init.CLKPolarity       = SPI_POLARITY_LOW;
  431.     SpiHandle.Init.DataSize          = SPI_DATASIZE_8BIT;
  432.     SpiHandle.Init.FirstBit          = SPI_FIRSTBIT_MSB;
  433.     SpiHandle.Init.TIMode            = SPI_TIMODE_DISABLE;
  434.     SpiHandle.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;
  435.     SpiHandle.Init.CRCPolynomial     = 7;
  436.     SpiHandle.Init.NSS               = SPI_NSS_SOFT;
  437.     SpiHandle.Init.Mode              = SPI_MODE_MASTER;
  438.     HAL_SPI_Init(&SpiHandle);
  439.    
  440. #ifdef IL9341_USE_DMA
  441.     /* set up SPI DMA */
  442.     IL9341_SPI_InitDMA();
  443. #endif
  444.  
  445.     /* Enable SPI */
  446.     __HAL_SPI_ENABLE(&SpiHandle);
  447. }
  448.  
  449. /* ----------------------- Public functions ----------------------- */
  450. /*
  451.  * send single byte via SPI - cmd or data depends on bit 8
  452.  */
  453. void IL9341_write(uint16_t dat)
  454. {
  455.     /* wait for pending transactions to complete */
  456.     while(il9341_spi_lock);
  457.    
  458.     /* take the lock */
  459.     il9341_spi_lock = 1;
  460.    
  461.     /* command or data */
  462.     if((dat&IL9341_CMD) == IL9341_CMD)
  463.         IL9341_DC_CMD();
  464.     else
  465.         IL9341_DC_DATA();
  466.    
  467.     /* assert CS */
  468.     IL9341_CS_LOW();
  469.  
  470.     /* Wait until the transmit buffer is empty */
  471.     while(__HAL_SPI_GET_FLAG(&SpiHandle, SPI_FLAG_TXE) == RESET);
  472.  
  473.     /* Send the byte */
  474.     *(__IO uint8_t *) ((uint32_t)IL9341_SPI_PORT+0x0C) = dat&0xff;
  475.    
  476.     /* wait for receive buffer full */
  477.     while(__HAL_SPI_GET_FLAG(&SpiHandle, SPI_FLAG_RXNE) == RESET);
  478.  
  479.     /* get the byte read from the SPI bus */
  480.     uint8_t dummy = *(__IO uint8_t *) ((uint32_t)IL9341_SPI_PORT+0x0C);
  481.  
  482.     /* de-assert CS */
  483.     IL9341_CS_HIGH();
  484.    
  485.     /* drop the lock */
  486.     il9341_spi_lock = 0;   
  487. }
  488.  
  489. #ifndef IL9341_NONBLOCKING
  490. /*
  491.  * send byte buffer to data - Blocking
  492.  */
  493. void IL9341_write_buffer(uint8_t *buffer, int32_t count)
  494. {
  495.     /* wait for pending transactions to complete */
  496.     while(il9341_spi_lock);
  497.    
  498.     /* take the lock */
  499.     il9341_spi_lock = 1;
  500.    
  501.     /* flag a buffer write */
  502.     IL9341_DIAG_HIGH();
  503.  
  504.     /* always data */
  505.     IL9341_DC_DATA();
  506.  
  507.     /* assert CS */
  508.     IL9341_CS_LOW();
  509.  
  510. #ifdef IL9341_USE_DMA
  511.     /* with DMA */
  512.     /* start a DMA transfer */
  513.     IL9341_SPI_start_DMA_WriteBytes(buffer, count);
  514.    
  515.     /* wait for it to end */
  516.     IL9341_SPI_end_DMA_WriteBytes();
  517. #else
  518.     /* PIO */
  519.     IL9341_SPI_Blocking_PIO_WriteBytes(&SpiHandle, buffer, count);
  520. #endif
  521.  
  522.     /* de-assert CS */
  523.     IL9341_CS_HIGH();
  524.  
  525.     /* clear buffer write flag */
  526.     IL9341_DIAG_LOW();
  527.    
  528.     /* drop the lock */
  529.     il9341_spi_lock = 0;   
  530. }
  531. #else
  532. #ifdef IL9341_USE_DMA
  533. /*
  534.  * send byte buffer to data - Non-blocking
  535.  */
  536. void IL9341_write_buffer(uint8_t *buffer, int32_t count)
  537. {
  538.     /* wait for pending transactions to complete */
  539.     while(il9341_spi_lock);
  540.    
  541.     /* take the lock */
  542.     il9341_spi_lock = 1;
  543.    
  544.     /* flag a buffer write */
  545.     IL9341_DIAG_HIGH();
  546.  
  547.     /* always data */
  548.     IL9341_DC_DATA();
  549.  
  550.     /* assert CS */
  551.     IL9341_CS_LOW();
  552.  
  553.     /* Start Non-blocking write with IRQ to end it */
  554.     IL9341_SPI_start_DMA_WriteBytes(buffer, count);
  555. }
  556. #else
  557.   #error "No non-blocking IO in PIO mode."
  558. #endif
  559. #endif
  560.  
  561. // Initialization for IL9341R
  562. void IL9341_init(void)
  563. {
  564.     /* disable lock */
  565.     il9341_spi_lock = 0;
  566.    
  567.     // init the SPI port
  568.     IL9341_SPI_Init();
  569.    
  570.     // default settings
  571.     _width  = IL9341_TFTWIDTH;
  572.     _height = IL9341_TFTHEIGHT;
  573.     rotation = 0;
  574.    
  575.     // Reset it
  576.     IL9341_RST_LOW();
  577.     HAL_Delay(10);
  578.     IL9341_RST_HIGH();
  579.     HAL_Delay(10);
  580.  
  581.     // Send init command list
  582.     uint16_t *addr = (uint16_t *)initlst, ms;
  583.     while(*addr != IL9341_END)
  584.     {
  585.         if((*addr & IL9341_DLY) != IL9341_DLY)
  586.             IL9341_write(*addr++);
  587.         else
  588.         {
  589.             ms = (*addr++)&0x1ff;        // strip delay time (ms)
  590.             HAL_Delay(ms);
  591.         }  
  592.     }
  593. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!