设为首页收藏本站
切换到宽版

极客工坊

 找回密码
 注册

QQ登录

只需一步，快速开始

极客工坊»首页 › Aduino与它的朋友们 › Arduino › 求助修改Adafruit上的液晶屏驱动库 Adafruit_ILI9341 让 ...
返回列表 发新帖
查看: 14334|回复: 10

求助修改Adafruit上的液晶屏驱动库 Adafruit_ILI9341 让其可以做三线SPI显示

[复制链接]
自由的Weesky
发表于 2015-12-25 15:35:56 | 显示全部楼层 |阅读模式
本帖最后由 自由的Weesky 于 2015-12-25 15:55 编辑

求助修改Adafruit上的液晶屏驱动库

Adafruit_ILI9341 让其可以做三线SPI显示，Adafruit上的库是4线SPI驱动。

愿意支付500元，需要3天搞定。
800元明天晚上前搞定

对于熟手来说，不是问题，一晚上改改就好。

提供，库文件参考，说明，

液晶屏电路板，逻辑转换芯片 免费提供一套！

不用发回给我了。


程序写好了，直接发到网站开源。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有帐号？注册

x
回复

使用道具 举报

自由的Weesky
 楼主| 发表于 2015-12-25 15:46:47 | 显示全部楼层
只要3个IO哦 SDA，SCL，CS
根据ILI9341手册，第一个CLK的SDA为低是写命令，第一个CLK的SDA为高是写数据！
回复 支持 反对

使用道具 举报

自由的Weesky
 楼主| 发表于 2015-12-25 15:51:57 | 显示全部楼层
本帖最后由 弘毅 于 2017-10-23 12:40 编辑

这是库文件的.cpp文件。

  1. /***************************************************
  2.   This is our library for the Adafruit ILI9341 Breakout and Shield
  3.   ----> http://www.adafruit.com/products/1651

  5.   Check out the links above for our tutorials and wiring diagrams
  6.   These displays use SPI to communicate, 4 or 5 pins are required to
  7.   interface (RST is optional)
  8.   Adafruit invests time and resources providing this open source code,
  9.   please support Adafruit and open-source hardware by purchasing
  10.   products from Adafruit!

  12.   Written by Limor Fried/Ladyada for Adafruit Industries.
  13.   MIT license, all text above must be included in any redistribution
  14. ****************************************************/

  16. #include "Adafruit_ILI9341.h"
  17. #include <avr/pgmspace.h>
  18. #include <limits.h>
  19. #include "pins_arduino.h"
  20. #include "wiring_private.h"
  21. #include <SPI.h>

  23. // Constructor when using software SPI.  All output pins are configurable.
  24. Adafruit_ILI9341::Adafruit_ILI9341(int8_t cs, int8_t dc, int8_t mosi,
  25.                                    int8_t sclk, int8_t rst, int8_t miso) : Adafruit_GFX(ILI9341_TFTWIDTH, ILI9341_TFTHEIGHT) {
  26.   _cs   = cs;
  27.   _dc   = dc;
  28.   _mosi  = mosi;
  29.   _miso = miso;
  30.   _sclk = sclk;
  31.   _rst  = rst;
  32.   hwSPI = false;
  33. }


  36. // Constructor when using hardware SPI.  Faster, but must use SPI pins
  37. // specific to each board type (e.g. 11,13 for Uno, 51,52 for Mega, etc.)
  38. Adafruit_ILI9341::Adafruit_ILI9341(int8_t cs, int8_t dc, int8_t rst) : Adafruit_GFX(ILI9341_TFTWIDTH, ILI9341_TFTHEIGHT) {
  39.   _cs   = cs;
  40.   _dc   = dc;
  41.   _rst  = rst;
  42.   hwSPI = true;
  43.   _mosi  = _sclk = 0;
  44. }

  46. void Adafruit_ILI9341::spiwrite(uint8_t c) {

  48.   //Serial.print("0x"); Serial.print(c, HEX); Serial.print(", ");

  50.   if (hwSPI) {
  51. #if defined (__AVR__)
  52.       uint8_t backupSPCR = SPCR;
  53.     SPCR = mySPCR;
  54.     SPDR = c;
  55.     while(!(SPSR & _BV(SPIF)));
  56.     SPCR = backupSPCR;
  57. #elif defined(TEENSYDUINO)
  58.     SPI.transfer(c);
  59. #elif defined (__arm__)
  60.     SPI.setClockDivider(11); // 8-ish MHz (full! speed!)
  61.     SPI.setBitOrder(MSBFIRST);
  62.     SPI.setDataMode(SPI_MODE0);
  63.     SPI.transfer(c);
  64. #endif
  65.   } else {
  66.     // Fast SPI bitbang swiped from LPD8806 library
  67.     for(uint8_t bit = 0x80; bit; bit >>= 1) {
  68.       if(c & bit) {
  69.         //digitalWrite(_mosi, HIGH);
  70.         *mosiport |=  mosipinmask;
  71.       } else {
  72.         //digitalWrite(_mosi, LOW);
  73.         *mosiport &= ~mosipinmask;
  74.       }
  75.       //digitalWrite(_sclk, HIGH);
  76.       *clkport |=  clkpinmask;
  77.       //digitalWrite(_sclk, LOW);
  78.       *clkport &= ~clkpinmask;
  79.     }
  80.   }
  81. }


  84. void Adafruit_ILI9341::writecommand(uint8_t c) {
  85.   *dcport &=  ~dcpinmask;
  86.   //digitalWrite(_dc, LOW);
  87.   //*clkport &= ~clkpinmask; // clkport is a NULL pointer when hwSPI==true
  88.   //digitalWrite(_sclk, LOW);
  89.   *csport &= ~cspinmask;
  90.   //digitalWrite(_cs, LOW);

  92.   spiwrite(c);

  94.   *csport |= cspinmask;
  95.   //digitalWrite(_cs, HIGH);
  96. }


  99. void Adafruit_ILI9341::writedata(uint8_t c) {
  100.   *dcport |=  dcpinmask;
  101.   //digitalWrite(_dc, HIGH);
  102.   //*clkport &= ~clkpinmask; // clkport is a NULL pointer when hwSPI==true
  103.   //digitalWrite(_sclk, LOW);
  104.   *csport &= ~cspinmask;
  105.   //digitalWrite(_cs, LOW);
  106.   
  107.   spiwrite(c);

  109.   //digitalWrite(_cs, HIGH);
  110.   *csport |= cspinmask;
  111. }

  113. // If the SPI library has transaction support, these functions
  114. // establish settings and protect from interference from other
  115. // libraries.  Otherwise, they simply do nothing.
  116. #ifdef SPI_HAS_TRANSACTION
  117. static inline void spi_begin(void) __attribute__((always_inline));
  118. static inline void spi_begin(void) {
  119.   SPI.beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0));
  120. }
  121. static inline void spi_end(void) __attribute__((always_inline));
  122. static inline void spi_end(void) {
  123.   SPI.endTransaction();
  124. }
  125. #else
  126. #define spi_begin()
  127. #define spi_end()
  128. #endif

  130. // Rather than a bazillion writecommand() and writedata() calls, screen
  131. // initialization commands and arguments are organized in these tables
  132. // stored in PROGMEM.  The table may look bulky, but that's mostly the
  133. // formatting -- storage-wise this is hundreds of bytes more compact
  134. // than the equivalent code.  Companion function follows.
  135. #define DELAY 0x80


  138. // Companion code to the above tables.  Reads and issues
  139. // a series of LCD commands stored in PROGMEM byte array.
  140. void Adafruit_ILI9341::commandList(uint8_t *addr) {

  142.   uint8_t  numCommands, numArgs;
  143.   uint16_t ms;

  145.   numCommands = pgm_read_byte(addr++);   // Number of commands to follow
  146.   while(numCommands--) {                 // For each command...
  147.     writecommand(pgm_read_byte(addr++)); //   Read, issue command
  148.     numArgs  = pgm_read_byte(addr++);    //   Number of args to follow
  149.     ms       = numArgs & DELAY;          //   If hibit set, delay follows args
  150.     numArgs &= ~DELAY;                   //   Mask out delay bit
  151.     while(numArgs--) {                   //   For each argument...
  152.       writedata(pgm_read_byte(addr++));  //     Read, issue argument
  153.     }

  155.     if(ms) {
  156.       ms = pgm_read_byte(addr++); // Read post-command delay time (ms)
  157.       if(ms == 255) ms = 500;     // If 255, delay for 500 ms
  158.       delay(ms);
  159.     }
  160.   }
  161. }


  164. void Adafruit_ILI9341::begin(void) {
  165.   if (_rst > 0) {
  166.     pinMode(_rst, OUTPUT);
  167.     digitalWrite(_rst, LOW);
  168.   }

  170.   pinMode(_dc, OUTPUT);
  171.   pinMode(_cs, OUTPUT);
  172.   csport    = portOutputRegister(digitalPinToPort(_cs));
  173.   cspinmask = digitalPinToBitMask(_cs);
  174.   dcport    = portOutputRegister(digitalPinToPort(_dc));
  175.   dcpinmask = digitalPinToBitMask(_dc);

  177.   if(hwSPI) { // Using hardware SPI
  178. #if defined (__AVR__)
  179.     SPI.begin();
  180.     SPI.setClockDivider(SPI_CLOCK_DIV2); // 8 MHz (full! speed!)
  181.     SPI.setBitOrder(MSBFIRST);
  182.     SPI.setDataMode(SPI_MODE0);
  183.     mySPCR = SPCR;
  184. #elif defined(TEENSYDUINO)
  185.     SPI.begin();
  186.     SPI.setClockDivider(SPI_CLOCK_DIV2); // 8 MHz (full! speed!)
  187.     SPI.setBitOrder(MSBFIRST);
  188.     SPI.setDataMode(SPI_MODE0);
  189. #elif defined (__arm__)
  190.       SPI.begin();
  191.       SPI.setClockDivider(11); // 8-ish MHz (full! speed!)
  192.       SPI.setBitOrder(MSBFIRST);
  193.       SPI.setDataMode(SPI_MODE0);
  194. #endif
  195.   } else {
  196.     pinMode(_sclk, OUTPUT);
  197.     pinMode(_mosi, OUTPUT);
  198.     pinMode(_miso, INPUT);
  199.     clkport     = portOutputRegister(digitalPinToPort(_sclk));
  200.     clkpinmask  = digitalPinToBitMask(_sclk);
  201.     mosiport    = portOutputRegister(digitalPinToPort(_mosi));
  202.     mosipinmask = digitalPinToBitMask(_mosi);
  203.     *clkport   &= ~clkpinmask;
  204.     *mosiport  &= ~mosipinmask;
  205.   }

  207.   // toggle RST low to reset
  208.   if (_rst > 0) {
  209.     digitalWrite(_rst, HIGH);
  210.     delay(5);
  211.     digitalWrite(_rst, LOW);
  212.     delay(20);
  213.     digitalWrite(_rst, HIGH);
  214.     delay(150);
  215.   }

  217.   /*
  218.   uint8_t x = readcommand8(ILI9341_RDMODE);
  219.   Serial.print("\nDisplay Power Mode: 0x"); Serial.println(x, HEX);
  220.   x = readcommand8(ILI9341_RDMADCTL);
  221.   Serial.print("\nMADCTL Mode: 0x"); Serial.println(x, HEX);
  222.   x = readcommand8(ILI9341_RDPIXFMT);
  223.   Serial.print("\nPixel Format: 0x"); Serial.println(x, HEX);
  224.   x = readcommand8(ILI9341_RDIMGFMT);
  225.   Serial.print("\nImage Format: 0x"); Serial.println(x, HEX);
  226.   x = readcommand8(ILI9341_RDSELFDIAG);
  227.   Serial.print("\nSelf Diagnostic: 0x"); Serial.println(x, HEX);
  228. */
  229.   //if(cmdList) commandList(cmdList);
  230.   
  231.   if (hwSPI) spi_begin();
  232.   writecommand(0xEF);
  233.   writedata(0x03);
  234.   writedata(0x80);
  235.   writedata(0x02);

  237.   writecommand(0xCF);  
  238.   writedata(0x00);
  239.   writedata(0XC1);
  240.   writedata(0X30);

  242.   writecommand(0xED);  
  243.   writedata(0x64);
  244.   writedata(0x03);
  245.   writedata(0X12);
  246.   writedata(0X81);

  248.   writecommand(0xE8);  
  249.   writedata(0x85);
  250.   writedata(0x00);
  251.   writedata(0x78);

  253.   writecommand(0xCB);  
  254.   writedata(0x39);
  255.   writedata(0x2C);
  256.   writedata(0x00);
  257.   writedata(0x34);
  258.   writedata(0x02);

  260.   writecommand(0xF7);  
  261.   writedata(0x20);

  263.   writecommand(0xEA);  
  264.   writedata(0x00);
  265.   writedata(0x00);

  267.   writecommand(ILI9341_PWCTR1);    //Power control
  268.   writedata(0x23);   //VRH[5:0]

  270.   writecommand(ILI9341_PWCTR2);    //Power control
  271.   writedata(0x10);   //SAP[2:0];BT[3:0]

  273.   writecommand(ILI9341_VMCTR1);    //VCM control
  274.   writedata(0x3e); //对比度调节
  275.   writedata(0x28);
  276.   
  277.   writecommand(ILI9341_VMCTR2);    //VCM control2
  278.   writedata(0x86);  //--

  280.   writecommand(ILI9341_MADCTL);    // Memory Access Control
  281.   writedata(0x48);

  283.   writecommand(ILI9341_PIXFMT);   
  284.   writedata(0x55);
  285.   
  286.   writecommand(ILI9341_FRMCTR1);   
  287.   writedata(0x00);  
  288.   writedata(0x18);

  290.   writecommand(ILI9341_DFUNCTR);    // Display Function Control
  291.   writedata(0x08);
  292.   writedata(0x82);
  293.   writedata(0x27);  

  295.   writecommand(0xF2);    // 3Gamma Function Disable
  296.   writedata(0x00);

  298.   writecommand(ILI9341_GAMMASET);    //Gamma curve selected
  299.   writedata(0x01);

  301.   writecommand(ILI9341_GMCTRP1);    //Set Gamma
  302.   writedata(0x0F);
  303.   writedata(0x31);
  304.   writedata(0x2B);
  305.   writedata(0x0C);
  306.   writedata(0x0E);
  307.   writedata(0x08);
  308.   writedata(0x4E);
  309.   writedata(0xF1);
  310.   writedata(0x37);
  311.   writedata(0x07);
  312.   writedata(0x10);
  313.   writedata(0x03);
  314.   writedata(0x0E);
  315.   writedata(0x09);
  316.   writedata(0x00);
  317.   
  318.   writecommand(ILI9341_GMCTRN1);    //Set Gamma
  319.   writedata(0x00);
  320.   writedata(0x0E);
  321.   writedata(0x14);
  322.   writedata(0x03);
  323.   writedata(0x11);
  324.   writedata(0x07);
  325.   writedata(0x31);
  326.   writedata(0xC1);
  327.   writedata(0x48);
  328.   writedata(0x08);
  329.   writedata(0x0F);
  330.   writedata(0x0C);
  331.   writedata(0x31);
  332.   writedata(0x36);
  333.   writedata(0x0F);

  335.   writecommand(ILI9341_SLPOUT);    //Exit Sleep
  336.   if (hwSPI) spi_end();
  337.   delay(120);                
  338.   if (hwSPI) spi_begin();
  339.   writecommand(ILI9341_DISPON);    //Display on
  340.   if (hwSPI) spi_end();

  342. }


  345. void Adafruit_ILI9341::setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1,
  346. uint16_t y1) {

  348.   writecommand(ILI9341_CASET); // Column addr set
  349.   writedata(x0 >> 8);
  350.   writedata(x0 & 0xFF);     // XSTART
  351.   writedata(x1 >> 8);
  352.   writedata(x1 & 0xFF);     // XEND

  354.   writecommand(ILI9341_PASET); // Row addr set
  355.   writedata(y0>>8);
  356.   writedata(y0);     // YSTART
  357.   writedata(y1>>8);
  358.   writedata(y1);     // YEND

  360.   writecommand(ILI9341_RAMWR); // write to RAM
  361. }


  364. void Adafruit_ILI9341::pushColor(uint16_t color) {
  365.   if (hwSPI) spi_begin();
  366.   //digitalWrite(_dc, HIGH);
  367.   *dcport |=  dcpinmask;
  368.   //digitalWrite(_cs, LOW);
  369.   *csport &= ~cspinmask;

  371.   spiwrite(color >> 8);
  372.   spiwrite(color);

  374.   *csport |= cspinmask;
  375.   //digitalWrite(_cs, HIGH);
  376.   if (hwSPI) spi_end();
  377. }

  379. void Adafruit_ILI9341::drawPixel(int16_t x, int16_t y, uint16_t color) {

  381.   if((x < 0) ||(x >= _width) || (y < 0) || (y >= _height)) return;

  383.   if (hwSPI) spi_begin();
  384.   setAddrWindow(x,y,x+1,y+1);

  386.   //digitalWrite(_dc, HIGH);
  387.   *dcport |=  dcpinmask;
  388.   //digitalWrite(_cs, LOW);
  389.   *csport &= ~cspinmask;

  391.   spiwrite(color >> 8);
  392.   spiwrite(color);

  394.   *csport |= cspinmask;
  395.   //digitalWrite(_cs, HIGH);
  396.   if (hwSPI) spi_end();
  397. }


  400. void Adafruit_ILI9341::drawFastVLine(int16_t x, int16_t y, int16_t h,
  401. uint16_t color) {

  403.   // Rudimentary clipping
  404.   if((x >= _width) || (y >= _height)) return;

  406.   if((y+h-1) >= _height)
  407.     h = _height-y;

  409.   if (hwSPI) spi_begin();
  410.   setAddrWindow(x, y, x, y+h-1);

  412.   uint8_t hi = color >> 8, lo = color;

  414.   *dcport |=  dcpinmask;
  415.   //digitalWrite(_dc, HIGH);
  416.   *csport &= ~cspinmask;
  417.   //digitalWrite(_cs, LOW);

  419.   while (h--) {
  420.     spiwrite(hi);
  421.     spiwrite(lo);
  422.   }
  423.   *csport |= cspinmask;
  424.   //digitalWrite(_cs, HIGH);
  425.   if (hwSPI) spi_end();
  426. }


  429. void Adafruit_ILI9341::drawFastHLine(int16_t x, int16_t y, int16_t w,
  430.   uint16_t color) {

  432.   // Rudimentary clipping
  433.   if((x >= _width) || (y >= _height)) return;
  434.   if((x+w-1) >= _width)  w = _width-x;
  435.   if (hwSPI) spi_begin();
  436.   setAddrWindow(x, y, x+w-1, y);

  438.   uint8_t hi = color >> 8, lo = color;
  439.   *dcport |=  dcpinmask;
  440.   *csport &= ~cspinmask;
  441.   //digitalWrite(_dc, HIGH);
  442.   //digitalWrite(_cs, LOW);
  443.   while (w--) {
  444.     spiwrite(hi);
  445.     spiwrite(lo);
  446.   }
  447.   *csport |= cspinmask;
  448.   //digitalWrite(_cs, HIGH);
  449.   if (hwSPI) spi_end();
  450. }

  452. void Adafruit_ILI9341::fillScreen(uint16_t color) {
  453.   fillRect(0, 0,  _width, _height, color);
  454. }

  456. // fill a rectangle
  457. void Adafruit_ILI9341::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
  458.   uint16_t color) {

  460.   // rudimentary clipping (drawChar w/big text requires this)
  461.   if((x >= _width) || (y >= _height)) return;
  462.   if((x + w - 1) >= _width)  w = _width  - x;
  463.   if((y + h - 1) >= _height) h = _height - y;

  465.   if (hwSPI) spi_begin();
  466.   setAddrWindow(x, y, x+w-1, y+h-1);

  468.   uint8_t hi = color >> 8, lo = color;

  470.   *dcport |=  dcpinmask;
  471.   //digitalWrite(_dc, HIGH);
  472.   *csport &= ~cspinmask;
  473.   //digitalWrite(_cs, LOW);

  475.   for(y=h; y>0; y--) {
  476.     for(x=w; x>0; x--) {
  477.       spiwrite(hi);
  478.       spiwrite(lo);
  479.     }
  480.   }
  481.   //digitalWrite(_cs, HIGH);
  482.   *csport |= cspinmask;
  483.   if (hwSPI) spi_end();
  484. }


  487. // Pass 8-bit (each) R,G,B, get back 16-bit packed color
  488. uint16_t Adafruit_ILI9341::color565(uint8_t r, uint8_t g, uint8_t b) {
  489.   return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
  490. }


  493. #define MADCTL_MY  0x80
  494. #define MADCTL_MX  0x40
  495. #define MADCTL_MV  0x20
  496. #define MADCTL_ML  0x10
  497. #define MADCTL_RGB 0x00
  498. #define MADCTL_BGR 0x08
  499. #define MADCTL_MH  0x04

  501. void Adafruit_ILI9341::setRotation(uint8_t m) {

  503.   if (hwSPI) spi_begin();
  504.   writecommand(ILI9341_MADCTL);
  505.   rotation = m % 4; // can't be higher than 3
  506.   switch (rotation) {
  507.    case 0:
  508.      writedata(MADCTL_MX | MADCTL_BGR);
  509.      _width  = ILI9341_TFTWIDTH;
  510.      _height = ILI9341_TFTHEIGHT;
  511.      break;
  512.    case 1:
  513.      writedata(MADCTL_MV | MADCTL_BGR);
  514.      _width  = ILI9341_TFTHEIGHT;
  515.      _height = ILI9341_TFTWIDTH;
  516.      break;
  517.   case 2:
  518.     writedata(MADCTL_MY | MADCTL_BGR);
  519.      _width  = ILI9341_TFTWIDTH;
  520.      _height = ILI9341_TFTHEIGHT;
  521.     break;
  522.    case 3:
  523.      writedata(MADCTL_MX | MADCTL_MY | MADCTL_MV | MADCTL_BGR);
  524.      _width  = ILI9341_TFTHEIGHT;
  525.      _height = ILI9341_TFTWIDTH;
  526.      break;
  527.   }
  528.   if (hwSPI) spi_end();
  529. }


  532. void Adafruit_ILI9341::invertDisplay(boolean i) {
  533.   if (hwSPI) spi_begin();
  534.   writecommand(i ? ILI9341_INVON : ILI9341_INVOFF);
  535.   if (hwSPI) spi_end();
  536. }


  539. ////////// stuff not actively being used, but kept for posterity


  542. uint8_t Adafruit_ILI9341::spiread(void) {
  543.   uint8_t r = 0;

  545.   if (hwSPI) {
  546. #if defined (__AVR__)
  547.     uint8_t backupSPCR = SPCR;
  548.     SPCR = mySPCR;
  549.     SPDR = 0x00;
  550.     while(!(SPSR & _BV(SPIF)));
  551.     r = SPDR;
  552.     SPCR = backupSPCR;
  553. #elif defined(TEENSYDUINO)
  554.     r = SPI.transfer(0x00);
  555. #elif defined (__arm__)
  556.     SPI.setClockDivider(11); // 8-ish MHz (full! speed!)
  557.     SPI.setBitOrder(MSBFIRST);
  558.     SPI.setDataMode(SPI_MODE0);
  559.     r = SPI.transfer(0x00);
  560. #endif
  561.   } else {

  563.     for (uint8_t i=0; i<8; i++) {
  564.       digitalWrite(_sclk, LOW);
  565.       digitalWrite(_sclk, HIGH);
  566.       r <<= 1;
  567.       if (digitalRead(_miso))
  568.         r |= 0x1;
  569.     }
  570.   }
  571.   //Serial.print("read: 0x"); Serial.print(r, HEX);
  572.   
  573.   return r;
  574. }

  576. uint8_t Adafruit_ILI9341::readdata(void) {
  577.    digitalWrite(_dc, HIGH);
  578.    digitalWrite(_cs, LOW);
  579.    uint8_t r = spiread();
  580.    digitalWrite(_cs, HIGH);
  581.    
  582.    return r;
  583. }


  586. uint8_t Adafruit_ILI9341::readcommand8(uint8_t c, uint8_t index) {
  587.    if (hwSPI) spi_begin();
  588.    digitalWrite(_dc, LOW); // command
  589.    digitalWrite(_cs, LOW);
  590.    spiwrite(0xD9);  // woo sekret command?
  591.    digitalWrite(_dc, HIGH); // data
  592.    spiwrite(0x10 + index);
  593.    digitalWrite(_cs, HIGH);

  595.    digitalWrite(_dc, LOW);
  596.    digitalWrite(_sclk, LOW);
  597.    digitalWrite(_cs, LOW);
  598.    spiwrite(c);

  600.    digitalWrite(_dc, HIGH);
  601.    uint8_t r = spiread();
  602.    digitalWrite(_cs, HIGH);
  603.    if (hwSPI) spi_end();
  604.    return r;
  605. }



  609. /*

  611. uint16_t Adafruit_ILI9341::readcommand16(uint8_t c) {
  612. digitalWrite(_dc, LOW);
  613. if (_cs)
  614. digitalWrite(_cs, LOW);

  616. spiwrite(c);
  617. pinMode(_sid, INPUT); // input!
  618. uint16_t r = spiread();
  619. r <<= 8;
  620. r |= spiread();
  621. if (_cs)
  622. digitalWrite(_cs, HIGH);

  624. pinMode(_sid, OUTPUT); // back to output
  625. return r;
  626. }

  628. uint32_t Adafruit_ILI9341::readcommand32(uint8_t c) {
  629. digitalWrite(_dc, LOW);
  630. if (_cs)
  631. digitalWrite(_cs, LOW);
  632. spiwrite(c);
  633. pinMode(_sid, INPUT); // input!

  635. dummyclock();
  636. dummyclock();

  638. uint32_t r = spiread();
  639. r <<= 8;
  640. r |= spiread();
  641. r <<= 8;
  642. r |= spiread();
  643. r <<= 8;
  644. r |= spiread();
  645. if (_cs)
  646. digitalWrite(_cs, HIGH);

  648. pinMode(_sid, OUTPUT); // back to output
  649. return r;
  650. }

  652. */
复制代码
回复 支持 反对

使用道具 举报

lbh_sd
发表于 2015-12-26 11:05:54 | 显示全部楼层

没有三线SPI的ILI9341屏幕，只按照STM32的驱动修改了一下CPP类和测试程序。你测试一下吧。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有帐号？注册

x
回复 支持 反对

使用道具 举报

lbh_sd
发表于 2015-12-26 11:31:14 | 显示全部楼层
注意，测试前 Arduino IDE环境需要先安装 Adafruit_GFX的类库。
回复 支持 反对

使用道具 举报

自由的Weesky
 楼主| 发表于 2015-12-26 13:44:52 | 显示全部楼层
lbh_sd 发表于 2015-12-26 11:31
注意，测试前 Arduino IDE环境需要先安装 Adafruit_GFX的类库。

非常感谢您，我编译通过了。但是它并没有Work..一直白屏
回复 支持 反对

使用道具 举报

自由的Weesky
 楼主| 发表于 2015-12-26 14:27:05 | 显示全部楼层
另外，MOSI那个口是不是写错了，应该是11
回复 支持 反对

使用道具 举报

lbh_sd
发表于 2015-12-26 16:27:12 | 显示全部楼层

又按时序图核对了一下程序，有点小问题已修改，因三线SPI不支持读命令，还是需要下载测试。
软件SPI可以使用任意PIN。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有帐号？注册

x
回复 支持 反对

使用道具 举报

自由的Weesky
 楼主| 发表于 2015-12-26 19:01:50 | 显示全部楼层
屏幕已经有反映了，但是只有一点字，而且感觉液晶的颗粒感巨明显，像是隔行显示的。
正常情况下，这个应该是黑屏，彩色字。然后开始各种演示。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有帐号？注册

x
回复 支持 反对

使用道具 举报

自由的Weesky
 楼主| 发表于 2015-12-26 19:19:51 | 显示全部楼层
自由的Weesky 发表于 2015-12-26 19:01
屏幕已经有反映了，但是只有一点字，而且感觉液晶的颗粒感巨明显，像是隔行显示的。
正常情况下，这个应该 ...

至少证明，我的接线没问题了。路子对
回复 支持 反对

使用道具 举报

allen727hk
发表于 2017-10-23 11:58:24 | 显示全部楼层
帮顶一下, 三线 SPI 的 ILI9341
回复 支持 反对

使用道具 举报

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

本版积分规则 需要先绑定手机号

Archiver|联系我们|极客工坊

GMT+8, 2024-4-19 11:09 , Processed in 0.054012 second(s), 21 queries .

Powered by Discuz! X3.4 Licensed

Copyright © 2001-2021, Tencent Cloud.

快速回复 返回顶部 返回列表