Mark Peter Vargha
/
SPI_TFT_ILI9341
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Fork of
SPI_TFT_ILI9341
by 
Peter Drescher
Revision 11:59eca2723ec5, committed 2014-06-24
- Comitter:
- dreschpe
- Date:
- Tue Jun 24 15:37:52 2014 +0000
- Parent:
- 10:50f88bd5557f
- Child:
- 12:98cc5c193ecd
- Commit message:
- Add fast Version for NUCLEO L152RE
Changed in this revision
--- a/SPI_TFT_ILI9341.cpp Sun Jun 22 22:32:01 2014 +0000
+++ b/SPI_TFT_ILI9341.cpp Tue Jun 24 15:37:52 2014 +0000
@@ -16,6 +16,10 @@
// 22.10.13 Fixes for Kinetis Board - 8 bit spi
// 26.01.14 Change interface for BMP_16 to also use SD-cards
// 23.06.14 switch back to old Version - fork for L152
+// 24.06.14 Add compiler flag for optimized L152 version
+
+// exclude this file for platforms with optimized version
+#ifndef TARGET_NUCLEO_L152RE
#include "SPI_TFT_ILI9341.h"
#include "mbed.h"
@@ -26,11 +30,13 @@
//extern DigitalOut xx; // debug !!
SPI_TFT_ILI9341::SPI_TFT_ILI9341(PinName mosi, PinName miso, PinName sclk, PinName cs, PinName reset, PinName dc, const char *name)
- : GraphicsDisplay(name), _spi(mosi, miso, sclk), _cs(cs), _reset(reset), _dc(dc)
+ : GraphicsDisplay(name), SPI(mosi, miso, sclk,NC), _cs(cs), _reset(reset), _dc(dc)
{
- clk = sclk;
+
orientation = 0;
char_x = 0;
+ SPI::format(8,3); // 8 bit spi mode 3
+ SPI::frequency(10000000); // 10 Mhz SPI clock
tft_reset();
}
@@ -54,16 +60,16 @@
wr_cmd(0x36); // MEMORY_ACCESS_CONTROL
switch (orientation) {
case 0:
- _spi.write(0x48);
+ SPI::write(0x48);
break;
case 1:
- _spi.write(0x28);
+ SPI::write(0x28);
break;
case 2:
- _spi.write(0x88);
+ SPI::write(0x88);
break;
case 3:
- _spi.write(0xE8);
+ SPI::write(0xE8);
break;
}
_cs = 1;
@@ -77,7 +83,7 @@
{
_dc = 0;
_cs = 0;
- _spi.write(cmd); // mbed lib
+ SPI::write(cmd); // mbed lib
_dc = 1;
}
@@ -85,7 +91,7 @@
void SPI_TFT_ILI9341::wr_dat(unsigned char dat)
{
- _spi.write(dat); // mbed lib
+ SPI::write(dat); // mbed lib
}
@@ -97,9 +103,9 @@
char r;
_dc = 0;
_cs = 0;
- _spi.write(cmd); // mbed lib
+ SPI::write(cmd); // mbed lib
_cs = 1;
- r = _spi.write(0xff);
+ r = SPI::write(0xff);
_cs = 1;
return(r);
}
@@ -113,17 +119,17 @@
_cs = 0;
d = cmd;
d = d << 1;
- _spi.format(9,3); // we have to add a dummy clock cycle
- _spi.write(d);
- _spi.format(8,3);
+ SPI::format(9,3); // we have to add a dummy clock cycle
+ SPI::write(d);
+ SPI::format(8,3);
_dc = 1;
- r = _spi.write(0xff);
+ r = SPI::write(0xff);
d = r;
- r = _spi.write(0xff);
+ r = SPI::write(0xff);
d = (d << 8) | r;
- r = _spi.write(0xff);
+ r = SPI::write(0xff);
d = (d << 8) | r;
- r = _spi.write(0xff);
+ r = SPI::write(0xff);
d = (d << 8) | r;
_cs = 1;
return(d);
@@ -143,8 +149,6 @@
void SPI_TFT_ILI9341::tft_reset()
{
- _spi.format(8,3); // 8 bit spi mode 3
- _spi.frequency(10000000); // 10 Mhz SPI clock
_cs = 1; // cs high
_dc = 1; // dc high
_reset = 0; // display reset
@@ -159,113 +163,113 @@
/* Start Initial Sequence ----------------------------------------------------*/
wr_cmd(0xCF);
- _spi.write(0x00);
- _spi.write(0x83);
- _spi.write(0x30);
+ SPI::write(0x00);
+ SPI::write(0x83);
+ SPI::write(0x30);
_cs = 1;
wr_cmd(0xED);
- _spi.write(0x64);
- _spi.write(0x03);
- _spi.write(0x12);
- _spi.write(0x81);
+ SPI::write(0x64);
+ SPI::write(0x03);
+ SPI::write(0x12);
+ SPI::write(0x81);
_cs = 1;
wr_cmd(0xE8);
- _spi.write(0x85);
- _spi.write(0x01);
- _spi.write(0x79);
+ SPI::write(0x85);
+ SPI::write(0x01);
+ SPI::write(0x79);
_cs = 1;
wr_cmd(0xCB);
- _spi.write(0x39);
- _spi.write(0x2C);
- _spi.write(0x00);
- _spi.write(0x34);
- _spi.write(0x02);
+ SPI::write(0x39);
+ SPI::write(0x2C);
+ SPI::write(0x00);
+ SPI::write(0x34);
+ SPI::write(0x02);
_cs = 1;
wr_cmd(0xF7);
- _spi.write(0x20);
+ SPI::write(0x20);
_cs = 1;
wr_cmd(0xEA);
- _spi.write(0x00);
- _spi.write(0x00);
+ SPI::write(0x00);
+ SPI::write(0x00);
_cs = 1;
wr_cmd(0xC0); // POWER_CONTROL_1
- _spi.write(0x26);
+ SPI::write(0x26);
_cs = 1;
wr_cmd(0xC1); // POWER_CONTROL_2
- _spi.write(0x11);
+ SPI::write(0x11);
_cs = 1;
wr_cmd(0xC5); // VCOM_CONTROL_1
- _spi.write(0x35);
- _spi.write(0x3E);
+ SPI::write(0x35);
+ SPI::write(0x3E);
_cs = 1;
wr_cmd(0xC7); // VCOM_CONTROL_2
- _spi.write(0xBE);
+ SPI::write(0xBE);
_cs = 1;
wr_cmd(0x36); // MEMORY_ACCESS_CONTROL
- _spi.write(0x48);
+ SPI::write(0x48);
_cs = 1;
wr_cmd(0x3A); // COLMOD_PIXEL_FORMAT_SET
- _spi.write(0x55); // 16 bit pixel
+ SPI::write(0x55); // 16 bit pixel
_cs = 1;
wr_cmd(0xB1); // Frame Rate
- _spi.write(0x00);
- _spi.write(0x1B);
+ SPI::write(0x00);
+ SPI::write(0x1B);
_cs = 1;
wr_cmd(0xF2); // Gamma Function Disable
- _spi.write(0x08);
+ SPI::write(0x08);
_cs = 1;
wr_cmd(0x26);
- _spi.write(0x01); // gamma set for curve 01/2/04/08
+ SPI::write(0x01); // gamma set for curve 01/2/04/08
_cs = 1;
wr_cmd(0xE0); // positive gamma correction
- _spi.write(0x1F);
- _spi.write(0x1A);
- _spi.write(0x18);
- _spi.write(0x0A);
- _spi.write(0x0F);
- _spi.write(0x06);
- _spi.write(0x45);
- _spi.write(0x87);
- _spi.write(0x32);
- _spi.write(0x0A);
- _spi.write(0x07);
- _spi.write(0x02);
- _spi.write(0x07);
- _spi.write(0x05);
- _spi.write(0x00);
+ SPI::write(0x1F);
+ SPI::write(0x1A);
+ SPI::write(0x18);
+ SPI::write(0x0A);
+ SPI::write(0x0F);
+ SPI::write(0x06);
+ SPI::write(0x45);
+ SPI::write(0x87);
+ SPI::write(0x32);
+ SPI::write(0x0A);
+ SPI::write(0x07);
+ SPI::write(0x02);
+ SPI::write(0x07);
+ SPI::write(0x05);
+ SPI::write(0x00);
_cs = 1;
wr_cmd(0xE1); // negativ gamma correction
- _spi.write(0x00);
- _spi.write(0x25);
- _spi.write(0x27);
- _spi.write(0x05);
- _spi.write(0x10);
- _spi.write(0x09);
- _spi.write(0x3A);
- _spi.write(0x78);
- _spi.write(0x4D);
- _spi.write(0x05);
- _spi.write(0x18);
- _spi.write(0x0D);
- _spi.write(0x38);
- _spi.write(0x3A);
- _spi.write(0x1F);
+ SPI::write(0x00);
+ SPI::write(0x25);
+ SPI::write(0x27);
+ SPI::write(0x05);
+ SPI::write(0x10);
+ SPI::write(0x09);
+ SPI::write(0x3A);
+ SPI::write(0x78);
+ SPI::write(0x4D);
+ SPI::write(0x05);
+ SPI::write(0x18);
+ SPI::write(0x0D);
+ SPI::write(0x38);
+ SPI::write(0x3A);
+ SPI::write(0x1F);
_cs = 1;
WindowMax ();
@@ -277,14 +281,14 @@
//_cs = 1;
wr_cmd(0xB7); // entry mode
- _spi.write(0x07);
+ SPI::write(0x07);
_cs = 1;
wr_cmd(0xB6); // display function control
- _spi.write(0x0A);
- _spi.write(0x82);
- _spi.write(0x27);
- _spi.write(0x00);
+ SPI::write(0x0A);
+ SPI::write(0x82);
+ SPI::write(0x27);
+ SPI::write(0x00);
_cs = 1;
wr_cmd(0x11); // sleep out
@@ -303,21 +307,21 @@
void SPI_TFT_ILI9341::pixel(int x, int y, int color)
{
wr_cmd(0x2A);
- _spi.write(x >> 8);
- _spi.write(x);
+ SPI::write(x >> 8);
+ SPI::write(x);
_cs = 1;
wr_cmd(0x2B);
- _spi.write(y >> 8);
- _spi.write(y);
+ SPI::write(y >> 8);
+ SPI::write(y);
_cs = 1;
wr_cmd(0x2C); // send pixel
#if defined TARGET_KL25Z // 8 Bit SPI
- _spi.write(color >> 8);
- _spi.write(color & 0xff);
+ SPI::write(color >> 8);
+ SPI::write(color & 0xff);
#else
- _spi.format(16,3); // switch to 16 bit Mode 3
- _spi.write(color); // Write D0..D15
- _spi.format(8,3);
+ SPI::format(16,3); // switch to 16 bit Mode 3
+ SPI::write(color); // Write D0..D15
+ SPI::format(8,3);
#endif
_cs = 1;
}
@@ -326,17 +330,17 @@
void SPI_TFT_ILI9341::window (unsigned int x, unsigned int y, unsigned int w, unsigned int h)
{
wr_cmd(0x2A);
- _spi.write(x >> 8);
- _spi.write(x);
- _spi.write((x+w-1) >> 8);
- _spi.write(x+w-1);
+ SPI::write(x >> 8);
+ SPI::write(x);
+ SPI::write((x+w-1) >> 8);
+ SPI::write(x+w-1);
_cs = 1;
wr_cmd(0x2B);
- _spi.write(y >> 8);
- _spi.write(y);
- _spi.write((y+h-1) >> 8);
- _spi.write(y+h-1);
+ SPI::write(y >> 8);
+ SPI::write(y);
+ SPI::write((y+h-1) >> 8);
+ SPI::write(y+h-1);
_cs = 1;
}
@@ -356,16 +360,16 @@
#if defined TARGET_KL25Z // 8 Bit SPI
unsigned int i;
for (i = 0; i < ( width() * height()); i++){
- _spi.write(_background >> 8);
- _spi.write(_background & 0xff);
+ SPI::write(_background >> 8);
+ SPI::write(_background & 0xff);
}
#else
- _spi.format(16,3); // switch to 16 bit Mode 3
+ SPI::format(16,3); // switch to 16 bit Mode 3
unsigned int i;
for (i = 0; i < ( width() * height()); i++)
- _spi.write(_background);
- _spi.format(8,3);
+ SPI::write(_background);
+ SPI::format(8,3);
#endif
_cs = 1;
}
@@ -415,16 +419,16 @@
#if defined TARGET_KL25Z // 8 Bit SPI
int j;
for (j=0; j<w; j++) {
- _spi.write(color >> 8);
- _spi.write(color & 0xff);
+ SPI::write(color >> 8);
+ SPI::write(color & 0xff);
}
#else
- _spi.format(16,3); // switch to 16 bit Mode 3
+ SPI::format(16,3); // switch to 16 bit Mode 3
int j;
for (j=0; j<w; j++) {
- _spi.write(color);
+ SPI::write(color);
}
- _spi.format(8,3);
+ SPI::format(8,3);
#endif
_cs = 1;
WindowMax();
@@ -439,15 +443,15 @@
wr_cmd(0x2C); // send pixel
#if defined TARGET_KL25Z // 8 Bit SPI
for (int y=0; y<h; y++) {
- _spi.write(color >> 8);
- _spi.write(color & 0xff);
+ SPI::write(color >> 8);
+ SPI::write(color & 0xff);
}
#else
- _spi.format(16,3); // switch to 16 bit Mode 3
+ SPI::format(16,3); // switch to 16 bit Mode 3
for (int y=0; y<h; y++) {
- _spi.write(color);
+ SPI::write(color);
}
- _spi.format(8,3);
+ SPI::format(8,3);
#endif
_cs = 1;
WindowMax();
@@ -558,15 +562,15 @@
wr_cmd(0x2C); // send pixel
#if defined TARGET_KL25Z // 8 Bit SPI
for (int p=0; p<pixel; p++) {
- _spi.write(color >> 8);
- _spi.write(color & 0xff);
+ SPI::write(color >> 8);
+ SPI::write(color & 0xff);
}
#else
- _spi.format(16,3); // switch to 16 bit Mode 3
+ SPI::format(16,3); // switch to 16 bit Mode 3
for (int p=0; p<pixel; p++) {
- _spi.write(color);
+ SPI::write(color);
}
- _spi.format(8,3);
+ SPI::format(8,3);
#endif
_cs = 1;
WindowMax();
@@ -635,7 +639,7 @@
window(char_x, char_y,hor,vert); // char box
wr_cmd(0x2C); // send pixel
#ifndef TARGET_KL25Z // 16 Bit SPI
- _spi.format(16,3);
+ SPI::format(16,3);
#endif // switch to 16 bit Mode 3
zeichen = &font[((c -32) * offset) + 4]; // start of char bitmap
w = zeichen[0]; // width of actual char
@@ -645,24 +649,24 @@
b = 1 << (j & 0x07);
if (( z & b ) == 0x00) {
#ifndef TARGET_KL25Z // 16 Bit SPI
- _spi.write(_background);
+ SPI::write(_background);
#else
- _spi.write(_background >> 8);
- _spi.write(_background & 0xff);
+ SPI::write(_background >> 8);
+ SPI::write(_background & 0xff);
#endif
} else {
#ifndef TARGET_KL25Z // 16 Bit SPI
- _spi.write(_foreground);
+ SPI::write(_foreground);
#else
- _spi.write(_foreground >> 8);
- _spi.write(_foreground & 0xff);
+ SPI::write(_foreground >> 8);
+ SPI::write(_foreground & 0xff);
#endif
}
}
}
_cs = 1;
#ifndef TARGET_KL25Z // 16 Bit SPI
- _spi.format(8,3);
+ SPI::format(8,3);
#endif
WindowMax();
if ((w + 2) < hor) { // x offset to next char
@@ -698,17 +702,17 @@
bitmap_ptr += ((h - 1)* (w + padd));
wr_cmd(0x2C); // send pixel
#ifndef TARGET_KL25Z // 16 Bit SPI
- _spi.format(16,3);
+ SPI::format(16,3);
#endif // switch to 16 bit Mode 3
for (j = 0; j < h; j++) { //Lines
for (i = 0; i < w; i++) { // one line
#if defined TARGET_KL25Z // 8 Bit SPI
pix_temp = *bitmap_ptr;
- _spi.write(pix_temp >> 8);
- _spi.write(pix_temp);
+ SPI::write(pix_temp >> 8);
+ SPI::write(pix_temp);
bitmap_ptr++;
#else
- _spi.write(*bitmap_ptr); // one line
+ SPI::write(*bitmap_ptr); // one line
bitmap_ptr++;
#endif
}
@@ -717,7 +721,7 @@
}
_cs = 1;
#ifndef TARGET_KL25Z // 16 Bit SPI
- _spi.format(8,3);
+ SPI::format(8,3);
#endif
WindowMax();
}
@@ -790,7 +794,7 @@
window(x, y,PixelWidth ,PixelHeigh);
wr_cmd(0x2C); // send pixel
#ifndef TARGET_KL25Z // only 8 Bit SPI
- _spi.format(16,3);
+ SPI::format(16,3);
#endif // switch to 16 bit Mode 3
for (j = PixelHeigh - 1; j >= 0; j--) { //Lines bottom up
off = j * (PixelWidth * 2 + padd) + start_data; // start of line
@@ -798,17 +802,19 @@
fread(line,1,PixelWidth * 2,Image); // read a line - slow
for (i = 0; i < PixelWidth; i++) { // copy pixel data to TFT
#ifndef TARGET_KL25Z // only 8 Bit SPI
- _spi.write(line[i]); // one 16 bit pixel
+ SPI::write(line[i]); // one 16 bit pixel
#else
- _spi.write(line[i] >> 8);
- _spi.write(line[i]);
+ SPI::write(line[i] >> 8);
+ SPI::write(line[i]);
#endif
}
}
_cs = 1;
- _spi.format(8,3);
+ SPI::format(8,3);
free (line);
fclose(Image);
WindowMax();
return(1);
}
+
+#endif
\ No newline at end of file
--- a/SPI_TFT_ILI9341.h Sun Jun 22 22:32:01 2014 +0000
+++ b/SPI_TFT_ILI9341.h Tue Jun 24 15:37:52 2014 +0000
@@ -13,7 +13,6 @@
/* change the char position handling
* use pixel (x,y) instadt of colum row */
-
#ifndef MBED_SPI_TFT_ILI9341_H
#define MBED_SPI_TFT_ILI9341_H
@@ -78,7 +77,7 @@
* }
* @endcode
*/
- class SPI_TFT_ILI9341 : public GraphicsDisplay {
+ class SPI_TFT_ILI9341 : public GraphicsDisplay , public SPI {
public:
/** Create a SPI_TFT object connected to SPI and three pins
@@ -278,9 +277,6 @@
*/
int Read_ID(void);
-
-
- SPI _spi;
DigitalOut _cs;
DigitalOut _reset;
DigitalOut _dc;
@@ -390,12 +386,24 @@
*/
//unsigned short rd_reg (unsigned char reg);
+ #ifdef TARGET_NUCLEO_L152RE
+ /** fast SPI write function for optimized versions
+ *
+ * @param data data written to SPI
+ *
+ */
+ virtual void f_write(int data);
+ virtual void spi_bsy(void);
+ virtual void spi_16(bool s);
+
+ #endif
+
unsigned char spi_port;
unsigned int orientation;
unsigned int char_x;
unsigned int char_y;
- PinName clk;
-
+ unsigned char spi_num;
+
};
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/SPI_TFT_ILI9341_L152.cpp Tue Jun 24 15:37:52 2014 +0000
@@ -0,0 +1,1119 @@
+/* mbed library for 240*320 pixel display TFT based on ILI9341 LCD Controller
+ * Copyright (c) 2013, 2014 Peter Drescher - DC2PD
+ * Special version for STM Nucleo -L152
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+ // 24.06.14 initial version
+
+// only include this file if target is L152 :
+#ifdef TARGET_NUCLEO_L152RE
+
+#include "SPI_TFT_ILI9341.h"
+#include "mbed.h"
+#include "stm32l1xx_dma.h"
+#include "stm32l1xx_rcc.h"
+#include "stm32l1xx_spi.h"
+
+#define BPP 16 // Bits per pixel
+
+//extern Serial pc;
+//extern DigitalOut xx; // debug !!
+
+DMA_InitTypeDef DMA_InitStructure;
+
+
+SPI_TFT_ILI9341::SPI_TFT_ILI9341(PinName mosi, PinName miso, PinName sclk, PinName cs, PinName reset, PinName dc, const char *name)
+ : GraphicsDisplay(name), SPI(mosi,miso,sclk,NC), _cs(cs), _reset(reset), _dc(dc)
+{
+
+ format(8,3); // 8 bit spi mode 3
+ frequency(10000000); // 10 Mhz SPI clock : result 2 / 4 = 8
+ orientation = 0;
+ char_x = 0;
+ if(_spi.spi == SPI_1){ // test which SPI is in use
+ spi_num = 1;
+ }
+ if(_spi.spi == SPI_2){
+ spi_num = 2;
+ }
+ if(_spi.spi == SPI_3){
+ spi_num = 3;
+ }
+ tft_reset();
+}
+
+// we define a fast write to the SPI port
+// we use the bit banding address to get the flag without masking
+
+#define bit_SPI1_txe *((volatile unsigned int *)0x42260104)
+#define SPI1_DR *((volatile unsigned int *)0x4001300C)
+#define bit_SPI2_txe *((volatile unsigned int *)0x42070104)
+#define SPI2_DR *((volatile unsigned int *)0x4000380C)
+#define bit_SPI3_txe *((volatile unsigned int *)0x42078104)
+#define SPI3_DR *((volatile unsigned int *)0x40003C0C)
+
+void SPI_TFT_ILI9341::f_write(int data){
+
+switch(spi_num){ // used SPI port
+case (1):
+ while(bit_SPI1_txe == 0); // wait for SPI1->SR TXE flag
+ SPI1_DR = data;
+ break;
+
+case (2):
+ while( bit_SPI2_txe == 0); // wait for SPI2->SR TXE flag
+ SPI2_DR = data;
+ break;
+
+case (3):
+ while( bit_SPI3_txe == 0); // wait for SPI3->SR TXE flag
+ SPI3_DR = data;
+ break;
+
+ }
+}
+
+// wait for SPI not busy
+// we have to wait for the last bit to switch the cs off
+// we use the bit banding address to get the flag without masking
+
+#define bit_SPI1_bsy *((volatile unsigned int *)0x4226011C)
+#define bit_SPI2_bsy *((volatile unsigned int *)0x4207011C)
+#define bit_SPI3_bsy *((volatile unsigned int *)0x4207811C)
+
+void inline SPI_TFT_ILI9341::spi_bsy(void){
+switch(spi_num){ // decide which SPI is to use
+case (1):
+ while(bit_SPI1_bsy == 1); // SPI1->SR bit 7
+ break;
+
+case (2):
+ while(bit_SPI2_bsy == 1); // SPI2->SR bit 7
+ break;
+
+case (3):
+ while(bit_SPI3_bsy == 1); // SPI2->SR bit 7
+ break;
+ }
+}
+
+
+// switch fast between 8 and 16 bit mode
+#define bit_SPI1_dff *((volatile unsigned int *)0x4226002C)
+#define bit_SPI2_dff *((volatile unsigned int *)0x4207002C)
+#define bit_SPI3_dff *((volatile unsigned int *)0x4207802C)
+void SPI_TFT_ILI9341::spi_16(bool s){
+switch(spi_num){ // decide which SPI is to use
+case(1):
+ if(s) bit_SPI1_dff = 1; // switch to 16 bit Mode
+ else bit_SPI1_dff = 0; // switch to 8 bit Mode
+ break;
+
+case(2):
+ if(s) bit_SPI2_dff = 1; // switch to 16 bit Mode
+ else bit_SPI2_dff = 0; // switch to 8 bit Mode
+ break;
+
+case(3):
+ if(s) bit_SPI3_dff = 1; // switch to 16 bit Mode
+ else bit_SPI3_dff = 0; // switch to 8 bit Mode
+ break;
+ }
+}
+
+
+int SPI_TFT_ILI9341::width()
+{
+ if (orientation == 0 || orientation == 2) return 240;
+ else return 320;
+}
+
+
+int SPI_TFT_ILI9341::height()
+{
+ if (orientation == 0 || orientation == 2) return 320;
+ else return 240;
+}
+
+
+void SPI_TFT_ILI9341::set_orientation(unsigned int o)
+{
+ orientation = o;
+ wr_cmd(0x36); // MEMORY_ACCESS_CONTROL
+ switch (orientation) {
+ case 0:
+ f_write(0x48);
+ break;
+ case 1:
+ f_write(0x28);
+ break;
+ case 2:
+ f_write(0x88);
+ break;
+ case 3:
+ f_write(0xE8);
+ break;
+ }
+ spi_bsy(); // wait for end of transfer
+ _cs = 1;
+ WindowMax();
+}
+
+
+// write command to tft register
+// use fast command
+void SPI_TFT_ILI9341::wr_cmd(unsigned char cmd)
+{
+ _dc = 0;
+ _cs = 0;
+ f_write(cmd);
+ spi_bsy();
+ _dc = 1;
+}
+
+void SPI_TFT_ILI9341::wr_dat(unsigned char dat)
+{
+ f_write(dat);
+ spi_bsy(); // wait for SPI send
+}
+
+// the ILI9341 can read
+char SPI_TFT_ILI9341::rd_byte(unsigned char cmd)
+{
+ char r;
+ _dc = 0;
+ _cs = 0;
+ SPI1->DR = cmd;
+ do{}while(SPI1->SR & 0x02 == 0); // wait for SPI send
+ SPI1->DR = 0xFF;
+ do{}while(SPI1->SR & 0x02 == 0); // wait for SPI send
+ r = SPI1->DR;
+ _cs = 1;
+ return(r);
+}
+
+// read 32 bit
+int SPI_TFT_ILI9341::rd_32(unsigned char cmd)
+{
+ int d;
+ char r;
+ _dc = 0;
+ _cs = 0;
+ d = cmd;
+ d = d << 1;
+ format(9,3); // we have to add a dummy clock cycle
+ f_write(d);
+ format(8,3);
+ _dc = 1;
+ //r = _spi.spi write(0xff);
+ d = r;
+ //r = f_write(0xff);
+ d = (d << 8) | r;
+ //r = f_write(0xff);
+ d = (d << 8) | r;
+ //r = f_write(0xff);
+ d = (d << 8) | r;
+ _cs = 1;
+ return(d);
+}
+
+int SPI_TFT_ILI9341::Read_ID(void){
+ int r;
+ r = rd_byte(0x0A);
+ r = rd_byte(0x0A);
+ r = rd_byte(0x0A);
+ r = rd_byte(0x0A);
+ return(r);
+}
+
+
+// Init code based on MI0283QT datasheet
+// this code is called only at start
+// no need to be optimized
+
+void SPI_TFT_ILI9341::tft_reset()
+{
+ _cs = 1; // cs high
+ _dc = 1; // dc high
+ _reset = 0; // display reset
+
+ wait_us(50);
+ _reset = 1; // end hardware reset
+ wait_ms(5);
+
+ wr_cmd(0x01); // SW reset
+ wait_ms(5);
+ wr_cmd(0x28); // display off
+
+ /* Start Initial Sequence ----------------------------------------------------*/
+ wr_cmd(0xCF);
+ f_write(0x00);
+ f_write(0x83);
+ f_write(0x30);
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0xED);
+ f_write(0x64);
+ f_write(0x03);
+ f_write(0x12);
+ f_write(0x81);
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0xE8);
+ f_write(0x85);
+ f_write(0x01);
+ f_write(0x79);
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0xCB);
+ f_write(0x39);
+ f_write(0x2C);
+ f_write(0x00);
+ f_write(0x34);
+ f_write(0x02);
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0xF7);
+ f_write(0x20);
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0xEA);
+ f_write(0x00);
+ f_write(0x00);
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0xC0); // POWER_CONTROL_1
+ f_write(0x26);
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0xC1); // POWER_CONTROL_2
+ f_write(0x11);
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0xC5); // VCOM_CONTROL_1
+ f_write(0x35);
+ f_write(0x3E);
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0xC7); // VCOM_CONTROL_2
+ f_write(0xBE);
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0x36); // MEMORY_ACCESS_CONTROL
+ f_write(0x48);
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0x3A); // COLMOD_PIXEL_FORMAT_SET
+ f_write(0x55); // 16 bit pixel
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0xB1); // Frame Rate
+ f_write(0x00);
+ f_write(0x1B);
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0xF2); // Gamma Function Disable
+ f_write(0x08);
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0x26);
+ f_write(0x01); // gamma set for curve 01/2/04/08
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0xE0); // positive gamma correction
+ f_write(0x1F);
+ f_write(0x1A);
+ f_write(0x18);
+ f_write(0x0A);
+ f_write(0x0F);
+ f_write(0x06);
+ f_write(0x45);
+ f_write(0x87);
+ f_write(0x32);
+ f_write(0x0A);
+ f_write(0x07);
+ f_write(0x02);
+ f_write(0x07);
+ f_write(0x05);
+ f_write(0x00);
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0xE1); // negativ gamma correction
+ f_write(0x00);
+ f_write(0x25);
+ f_write(0x27);
+ f_write(0x05);
+ f_write(0x10);
+ f_write(0x09);
+ f_write(0x3A);
+ f_write(0x78);
+ f_write(0x4D);
+ f_write(0x05);
+ f_write(0x18);
+ f_write(0x0D);
+ f_write(0x38);
+ f_write(0x3A);
+ f_write(0x1F);
+ spi_bsy();
+ _cs = 1;
+
+ WindowMax ();
+
+ //wr_cmd(0x34); // tearing effect off
+ //_cs = 1;
+
+ //wr_cmd(0x35); // tearing effect on
+ //_cs = 1;
+
+ wr_cmd(0xB7); // entry mode
+ f_write(0x07);
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0xB6); // display function control
+ f_write(0x0A);
+ f_write(0x82);
+ f_write(0x27);
+ f_write(0x00);
+ spi_bsy();
+ _cs = 1;
+
+ wr_cmd(0x11); // sleep out
+ spi_bsy();
+ _cs = 1;
+
+ wait_ms(100);
+
+ wr_cmd(0x29); // display on
+ spi_bsy();
+ _cs = 1;
+
+ wait_ms(100);
+
+ // Configure the DMA controller init-structure
+ DMA_StructInit(&DMA_InitStructure);
+ switch(spi_num){ // decide which SPI is to use
+ case (1):
+ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); // SPI1 and SPI2 are using DMA 1
+ DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t) &(SPI1->DR);
+ break;
+ case (2):
+ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); // SPI1 and SPI2 are using DMA 1
+ DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t) &(SPI2->DR);
+ break;
+ case (3):
+ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA2, ENABLE); // SPI3 is using DMA 2
+ DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t) &(SPI3->DR);
+ break;
+ }
+ DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
+ DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
+ DMA_InitStructure.DMA_BufferSize = 0;
+ DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
+ DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
+ DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
+ DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
+ DMA_InitStructure.DMA_Priority = DMA_Priority_High;
+ }
+
+
+// speed optimized
+// write direct to SPI1 register !
+void SPI_TFT_ILI9341::pixel(int x, int y, int color)
+{
+ wr_cmd(0x2A);
+ spi_16(1); // switch to 8 bit Mode
+ f_write(x);
+ spi_bsy();
+ _cs = 1;
+
+ spi_16(0); // switch to 8 bit Mode
+ wr_cmd(0x2B);
+ spi_16(1);
+ f_write(y);
+ spi_bsy();
+ _cs = 1;
+ spi_16(0);
+
+ wr_cmd(0x2C); // send pixel
+ spi_16(1);
+ f_write(color);
+ spi_bsy();
+ _cs = 1;
+ spi_16(0);
+}
+
+// optimized
+// write direct to SPI1 register !
+void SPI_TFT_ILI9341::window (unsigned int x, unsigned int y, unsigned int w, unsigned int h)
+{
+ wr_cmd(0x2A);
+ spi_16(1);
+ f_write(x);
+ f_write(x+w-1);
+ spi_bsy();
+ _cs = 1;
+ spi_16(0);
+
+ wr_cmd(0x2B);
+ spi_16(1);
+ f_write(y) ;
+ f_write(y+h-1);
+ spi_bsy();
+ _cs = 1;
+ spi_16(0);
+}
+
+
+void SPI_TFT_ILI9341::WindowMax (void)
+{
+ window (0, 0, width(), height());
+}
+
+// optimized
+// use DMA to transfer pixel data to the screen
+void SPI_TFT_ILI9341::cls (void)
+{
+ //int pixel = ( width() * height());
+ WindowMax();
+ wr_cmd(0x2C); // send pixel
+ spi_16(1); // switch to 16 bit Mode
+
+ // set up the DMA structure for single byte
+ DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) &_background;
+ DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;
+ switch(spi_num){ // decide which SPI is to use
+ case (1):
+ DMA_Init(DMA1_Channel3, &DMA_InitStructure); // init the DMA
+ // we have to send 2 blocks of pixel date, because the DMA counter can only transfer 64k
+ DMA_SetCurrDataCounter(DMA1_Channel3, 38400); // 1.half of screen
+ SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx,ENABLE);
+ DMA_Cmd(DMA1_Channel3, ENABLE);
+ do{
+ }while(DMA_GetCurrDataCounter(DMA1_Channel3) != 0); // wait for end of transfer
+ DMA_Cmd(DMA1_Channel3, DISABLE);
+ DMA_SetCurrDataCounter(DMA1_Channel3, 38400); // 2.half of screen
+ DMA_Cmd(DMA1_Channel3, ENABLE);
+ do{
+ }while(DMA_GetCurrDataCounter(DMA1_Channel3) != 0); // wait for end of transfer
+ DMA_Cmd(DMA1_Channel3, DISABLE);
+ break;
+
+ case (2):
+ DMA_Init(DMA1_Channel5, &DMA_InitStructure); // init the DMA
+ // we have to send 2 blocks of pixel date, because the DMA counter can only transfer 64k
+ DMA_SetCurrDataCounter(DMA1_Channel5, 38400); // 1.half of screen
+ SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx,ENABLE);
+ DMA_Cmd(DMA1_Channel5, ENABLE);
+ do{
+ }while(DMA_GetCurrDataCounter(DMA1_Channel5) != 0); // wait for end of transfer
+ DMA_Cmd(DMA1_Channel5, DISABLE);
+ DMA_SetCurrDataCounter(DMA1_Channel5, 38400); // 2.half of screen
+ DMA_Cmd(DMA1_Channel5, ENABLE);
+ do{
+ }while(DMA_GetCurrDataCounter(DMA1_Channel5) != 0); // wait for end of transfer
+ DMA_Cmd(DMA1_Channel5, DISABLE);
+ break;
+
+ case (3):
+ DMA_Init(DMA2_Channel2, &DMA_InitStructure); // init the DMA
+ // we have to send 2 blocks of pixel date, because the DMA counter can only transfer 64k
+ DMA_SetCurrDataCounter(DMA2_Channel2, 38400); // 1.half of screen
+ SPI_I2S_DMACmd(SPI3, SPI_I2S_DMAReq_Tx,ENABLE);
+ DMA_Cmd(DMA2_Channel2, ENABLE);
+ do{
+ }while(DMA_GetCurrDataCounter(DMA2_Channel2) != 0); // wait for end of transfer
+ DMA_Cmd(DMA2_Channel2, DISABLE);
+ DMA_SetCurrDataCounter(DMA2_Channel2, 38400); // 2.half of screen
+ DMA_Cmd(DMA2_Channel2, ENABLE);
+ do{
+ }while(DMA_GetCurrDataCounter(DMA2_Channel2) != 0); // wait for end of transfer
+ DMA_Cmd(DMA2_Channel2, DISABLE);
+ break;
+ }
+ spi_bsy();
+ _cs = 1;
+ spi_16(0);
+}
+
+
+void SPI_TFT_ILI9341::circle(int x0, int y0, int r, int color)
+{
+
+ int x = -r, y = 0, err = 2-2*r, e2;
+ do {
+ pixel(x0-x, y0+y,color);
+ pixel(x0+x, y0+y,color);
+ pixel(x0+x, y0-y,color);
+ pixel(x0-x, y0-y,color);
+ e2 = err;
+ if (e2 <= y) {
+ err += ++y*2+1;
+ if (-x == y && e2 <= x) e2 = 0;
+ }
+ if (e2 > x) err += ++x*2+1;
+ } while (x <= 0);
+}
+
+void SPI_TFT_ILI9341::fillcircle(int x0, int y0, int r, int color)
+{
+ int x = -r, y = 0, err = 2-2*r, e2;
+ do {
+ vline(x0-x, y0-y, y0+y, color);
+ vline(x0+x, y0-y, y0+y, color);
+ e2 = err;
+ if (e2 <= y) {
+ err += ++y*2+1;
+ if (-x == y && e2 <= x) e2 = 0;
+ }
+ if (e2 > x) err += ++x*2+1;
+ } while (x <= 0);
+}
+
+
+// optimized for speed
+void SPI_TFT_ILI9341::hline(int x0, int x1, int y, int color)
+{
+ int w,j;
+ w = x1 - x0 + 1;
+ window(x0,y,w,1);
+ _dc = 0;
+ _cs = 0;
+ f_write(0x2C); // send pixel
+ spi_bsy();
+ _dc = 1;
+ spi_16(1);
+
+ for (j=0; j<w; j++) {
+ f_write(color);
+ }
+ spi_bsy();
+ spi_16(0);
+ _cs = 1;
+ WindowMax();
+ return;
+}
+
+// optimized for speed
+void SPI_TFT_ILI9341::vline(int x, int y0, int y1, int color)
+{
+ int h,y;
+ h = y1 - y0 + 1;
+ window(x,y0,1,h);
+ _dc = 0;
+ _cs = 0;
+ f_write(0x2C); // send pixel
+ spi_bsy();
+ _dc = 1;
+ spi_16(1);
+ // switch to 16 bit Mode 3
+ for (y=0; y<h; y++) {
+ f_write(color);
+ }
+ spi_bsy();
+ spi_16(0);
+ _cs = 1;
+ WindowMax();
+ return;
+}
+
+
+void SPI_TFT_ILI9341::line(int x0, int y0, int x1, int y1, int color)
+{
+ //WindowMax();
+ int dx = 0, dy = 0;
+ int dx_sym = 0, dy_sym = 0;
+ int dx_x2 = 0, dy_x2 = 0;
+ int di = 0;
+
+ dx = x1-x0;
+ dy = y1-y0;
+
+ if (dx == 0) { /* vertical line */
+ if (y1 > y0) vline(x0,y0,y1,color);
+ else vline(x0,y1,y0,color);
+ return;
+ }
+
+ if (dx > 0) {
+ dx_sym = 1;
+ } else {
+ dx_sym = -1;
+ }
+ if (dy == 0) { /* horizontal line */
+ if (x1 > x0) hline(x0,x1,y0,color);
+ else hline(x1,x0,y0,color);
+ return;
+ }
+
+ if (dy > 0) {
+ dy_sym = 1;
+ } else {
+ dy_sym = -1;
+ }
+
+ dx = dx_sym*dx;
+ dy = dy_sym*dy;
+
+ dx_x2 = dx*2;
+ dy_x2 = dy*2;
+
+ if (dx >= dy) {
+ di = dy_x2 - dx;
+ while (x0 != x1) {
+
+ pixel(x0, y0, color);
+ x0 += dx_sym;
+ if (di<0) {
+ di += dy_x2;
+ } else {
+ di += dy_x2 - dx_x2;
+ y0 += dy_sym;
+ }
+ }
+ pixel(x0, y0, color);
+ } else {
+ di = dx_x2 - dy;
+ while (y0 != y1) {
+ pixel(x0, y0, color);
+ y0 += dy_sym;
+ if (di < 0) {
+ di += dx_x2;
+ } else {
+ di += dx_x2 - dy_x2;
+ x0 += dx_sym;
+ }
+ }
+ pixel(x0, y0, color);
+ }
+ return;
+}
+
+
+void SPI_TFT_ILI9341::rect(int x0, int y0, int x1, int y1, int color)
+{
+
+ if (x1 > x0) hline(x0,x1,y0,color);
+ else hline(x1,x0,y0,color);
+
+ if (y1 > y0) vline(x0,y0,y1,color);
+ else vline(x0,y1,y0,color);
+
+ if (x1 > x0) hline(x0,x1,y1,color);
+ else hline(x1,x0,y1,color);
+
+ if (y1 > y0) vline(x1,y0,y1,color);
+ else vline(x1,y1,y0,color);
+
+ return;
+}
+
+
+
+// optimized for speed
+// use DMA
+void SPI_TFT_ILI9341::fillrect(int x0, int y0, int x1, int y1, int color)
+{
+
+ int h = y1 - y0 + 1;
+ int w = x1 - x0 + 1;
+ int pixel = h * w;
+ unsigned int dma_transfer;
+ window(x0,y0,w,h);
+
+ wr_cmd(0x2C); // send pixel
+ spi_16(1);
+ DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) &color;
+ DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;
+
+ switch(spi_num){ // decide which SPI is to use
+ case (1):
+ DMA_Init(DMA1_Channel3, &DMA_InitStructure); // init the DMA
+ do{
+ if(pixel < 0x10000) {
+ dma_transfer = pixel;
+ pixel = 0;
+ }
+ else {
+ dma_transfer = 0xffff;
+ pixel = pixel - 0xffff;
+ }
+ DMA_SetCurrDataCounter(DMA1_Channel3, dma_transfer);
+ SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx,ENABLE);
+ DMA_Cmd(DMA1_Channel3, ENABLE);
+ while(DMA_GetCurrDataCounter(DMA1_Channel3) != 0); // wait for end of transfer
+ DMA_Cmd(DMA1_Channel3, DISABLE);
+ }while(pixel > 0);
+ break;
+
+ case (2):
+ DMA_Init(DMA1_Channel5, &DMA_InitStructure); // init the DMA
+ do{
+ if(pixel < 0x10000) {
+ dma_transfer = pixel;
+ pixel = 0;
+ }
+ else {
+ dma_transfer = 0xffff;
+ pixel = pixel - 0xffff;
+ }
+ DMA_SetCurrDataCounter(DMA1_Channel5, dma_transfer);
+ SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx,ENABLE);
+ DMA_Cmd(DMA1_Channel5, ENABLE);
+ while(DMA_GetCurrDataCounter(DMA1_Channel5) != 0); // wait for end of transfer
+ DMA_Cmd(DMA1_Channel5, DISABLE);
+ }while(pixel > 0);
+ break;
+
+ case (3):
+ DMA_Init(DMA2_Channel2, &DMA_InitStructure); // init the DMA
+ do{
+ if(pixel < 0x10000) {
+ dma_transfer = pixel;
+ pixel = 0;
+ }
+ else {
+ dma_transfer = 0xffff;
+ pixel = pixel - 0xffff;
+ }
+ DMA_SetCurrDataCounter(DMA2_Channel2, dma_transfer);
+ SPI_I2S_DMACmd(SPI3, SPI_I2S_DMAReq_Tx,ENABLE);
+ DMA_Cmd(DMA2_Channel2, ENABLE);
+ while(DMA_GetCurrDataCounter(DMA2_Channel2) != 0); // wait for end of transfer
+ DMA_Cmd(DMA2_Channel2, DISABLE);
+ }while(pixel > 0);
+ break;
+ }
+ spi_bsy();
+ spi_16(0);
+ _cs = 1;
+ WindowMax();
+ return;
+}
+
+void SPI_TFT_ILI9341::locate(int x, int y)
+{
+ char_x = x;
+ char_y = y;
+}
+
+int SPI_TFT_ILI9341::columns()
+{
+ return width() / font[1];
+}
+
+
+int SPI_TFT_ILI9341::rows()
+{
+ return height() / font[2];
+}
+
+
+int SPI_TFT_ILI9341::_putc(int value)
+{
+ if (value == '\n') { // new line
+ char_x = 0;
+ char_y = char_y + font[2];
+ if (char_y >= height() - font[2]) {
+ char_y = 0;
+ }
+ } else {
+ character(char_x, char_y, value);
+ }
+ return value;
+}
+
+
+// speed optimized
+// will use dma
+void SPI_TFT_ILI9341::character(int x, int y, int c)
+{
+ unsigned int hor,vert,offset,bpl,j,i,b;
+ unsigned char* zeichen;
+ unsigned char z,w;
+ unsigned int pixel;
+ unsigned int p;
+ unsigned int dma_count,dma_off;
+ uint16_t *buffer;
+
+ if ((c < 31) || (c > 127)) return; // test char range
+
+ // read font parameter from start of array
+ offset = font[0]; // bytes / char
+ hor = font[1]; // get hor size of font
+ vert = font[2]; // get vert size of font
+ bpl = font[3]; // bytes per line
+
+ if (char_x + hor > width()) {
+ char_x = 0;
+ char_y = char_y + vert;
+ if (char_y >= height() - font[2]) {
+ char_y = 0;
+ }
+ }
+ window(char_x, char_y,hor,vert); // setup char box
+ wr_cmd(0x2C);
+ pixel = hor * vert; // calculate buffer size
+ spi_16(1); // switch to 16 bit Mode
+ buffer = (uint16_t *) malloc (2*pixel); // we need a buffer for the font
+ if (buffer == NULL) { // there is no memory space -> use no dma
+ zeichen = &font[((c -32) * offset) + 4]; // start of char bitmap
+ w = zeichen[0]; // width of actual char
+ for (j=0; j<vert; j++) { // vert line
+ for (i=0; i<hor; i++) { // horz line
+ z = zeichen[bpl * i + ((j & 0xF8) >> 3)+1];
+ b = 1 << (j & 0x07);
+ if (( z & b ) == 0x00) {
+ f_write(_background);
+ } else {
+ f_write(_foreground);
+ }
+ }
+ }
+ spi_bsy();
+ _cs = 1;
+ spi_16(0);
+ }
+
+ // malloc ok, we can use DMA to transfer
+ else{
+ zeichen = &font[((c -32) * offset) + 4]; // start of char bitmap
+ w = zeichen[0]; // width of actual char
+ p = 0;
+ // construct the font into the buffer
+ for (j=0; j<vert; j++) { // vert line
+ for (i=0; i<hor; i++) { // horz line
+ z = zeichen[bpl * i + ((j & 0xF8) >> 3)+1];
+ b = 1 << (j & 0x07);
+ if (( z & b ) == 0x00) {
+ buffer[p] = _background;
+ } else {
+ buffer[p] = _foreground;
+ }
+ p++;
+ }
+ }
+ // copy the buffer with DMA SPI to display
+ dma_off = 0; // offset for DMA transfer
+ DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) (buffer + dma_off);
+ DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
+
+ switch(spi_num){ // decide which SPI is to use
+ case (1):
+ DMA_Init(DMA1_Channel3, &DMA_InitStructure); // init the DMA
+ // start DMA
+ do {
+ if (pixel > 0X10000) { // this is a giant font !
+ dma_count = 0Xffff;
+ pixel = pixel - 0Xffff;
+ } else {
+ dma_count = pixel;
+ pixel = 0;
+ }
+ DMA_SetCurrDataCounter(DMA1_Channel3, dma_count);
+ SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx,ENABLE);
+ DMA_Cmd(DMA1_Channel3, ENABLE);
+ while(DMA_GetCurrDataCounter(DMA1_Channel3) != 0); // wait for end of transfer
+ DMA_Cmd(DMA1_Channel3, DISABLE);
+ }while(pixel > 0);
+ break;
+
+ case (2):
+ DMA_Init(DMA1_Channel5, &DMA_InitStructure); // init the DMA
+ // start DMA
+ do {
+ if (pixel > 0X10000) { // this is a giant font !
+ dma_count = 0Xffff;
+ pixel = pixel - 0Xffff;
+ } else {
+ dma_count = pixel;
+ pixel = 0;
+ }
+ DMA_SetCurrDataCounter(DMA1_Channel5, dma_count);
+ SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx,ENABLE);
+ DMA_Cmd(DMA1_Channel5, ENABLE);
+ while(DMA_GetCurrDataCounter(DMA1_Channel5) != 0); // wait for end of transfer
+ DMA_Cmd(DMA1_Channel5, DISABLE);
+ }while(pixel > 0);
+ break;
+
+ case (3):
+ DMA_Init(DMA2_Channel2, &DMA_InitStructure); // init the DMA
+ // start DMA
+ do {
+ if (pixel > 0X10000) { // this is a giant font !
+ dma_count = 0Xffff;
+ pixel = pixel - 0Xffff;
+ } else {
+ dma_count = pixel;
+ pixel = 0;
+ }
+ DMA_SetCurrDataCounter(DMA2_Channel2, dma_count);
+ SPI_I2S_DMACmd(SPI3, SPI_I2S_DMAReq_Tx,ENABLE);
+ DMA_Cmd(DMA2_Channel2, ENABLE);
+ while(DMA_GetCurrDataCounter(DMA2_Channel2) != 0); // wait for end of transfer
+ DMA_Cmd(DMA2_Channel2, DISABLE);
+ }while(pixel > 0);
+ break;
+
+ }
+ spi_bsy();
+ free ((uint16_t *) buffer);
+ spi_16(0);
+ }
+ _cs = 1;
+ WindowMax();
+ if ((w + 2) < hor) { // x offset to next char
+ char_x += w + 2;
+ } else char_x += hor;
+}
+
+
+void SPI_TFT_ILI9341::set_font(unsigned char* f)
+{
+ font = f;
+}
+
+
+void SPI_TFT_ILI9341::Bitmap(unsigned int x, unsigned int y, unsigned int w, unsigned int h,unsigned char *bitmap)
+{
+ unsigned int j;
+ int padd;
+ unsigned short *bitmap_ptr = (unsigned short *)bitmap;
+
+ unsigned int i;
+
+ // the lines are padded to multiple of 4 bytes in a bitmap
+ padd = -1;
+ do {
+ padd ++;
+ } while (2*(w + padd)%4 != 0);
+ window(x, y, w, h);
+ bitmap_ptr += ((h - 1)* (w + padd));
+ wr_cmd(0x2C); // send pixel
+ spi_16(1);
+ for (j = 0; j < h; j++) { //Lines
+ for (i = 0; i < w; i++) { // one line
+ f_write(*bitmap_ptr); // one line
+ bitmap_ptr++;
+ }
+ bitmap_ptr -= 2*w;
+ bitmap_ptr -= padd;
+ }
+ spi_bsy();
+ _cs = 1;
+ spi_16(0);
+ WindowMax();
+}
+
+
+// local filesystem is not implemented but you can add a SD card to a different SPI
+
+int SPI_TFT_ILI9341::BMP_16(unsigned int x, unsigned int y, const char *Name_BMP)
+{
+
+#define OffsetPixelWidth 18
+#define OffsetPixelHeigh 22
+#define OffsetFileSize 34
+#define OffsetPixData 10
+#define OffsetBPP 28
+
+ char filename[50];
+ unsigned char BMP_Header[54];
+ unsigned short BPP_t;
+ unsigned int PixelWidth,PixelHeigh,start_data;
+ unsigned int i,off;
+ int padd,j;
+ unsigned short *line;
+
+ // get the filename
+ i=0;
+ while (*Name_BMP!='\0') {
+ filename[i++]=*Name_BMP++;
+ }
+ filename[i] = 0;
+
+ FILE *Image = fopen((const char *)&filename[0], "rb"); // open the bmp file
+ if (!Image) {
+ return(0); // error file not found !
+ }
+
+ fread(&BMP_Header[0],1,54,Image); // get the BMP Header
+
+ if (BMP_Header[0] != 0x42 || BMP_Header[1] != 0x4D) { // check magic byte
+ fclose(Image);
+ return(-1); // error no BMP file
+ }
+
+ BPP_t = BMP_Header[OffsetBPP] + (BMP_Header[OffsetBPP + 1] << 8);
+ if (BPP_t != 0x0010) {
+ fclose(Image);
+ return(-2); // error no 16 bit BMP
+ }
+
+ PixelHeigh = BMP_Header[OffsetPixelHeigh] + (BMP_Header[OffsetPixelHeigh + 1] << 8) + (BMP_Header[OffsetPixelHeigh + 2] << 16) + (BMP_Header[OffsetPixelHeigh + 3] << 24);
+ PixelWidth = BMP_Header[OffsetPixelWidth] + (BMP_Header[OffsetPixelWidth + 1] << 8) + (BMP_Header[OffsetPixelWidth + 2] << 16) + (BMP_Header[OffsetPixelWidth + 3] << 24);
+ if (PixelHeigh > height() + y || PixelWidth > width() + x) {
+ fclose(Image);
+ return(-3); // to big
+ }
+
+ start_data = BMP_Header[OffsetPixData] + (BMP_Header[OffsetPixData + 1] << 8) + (BMP_Header[OffsetPixData + 2] << 16) + (BMP_Header[OffsetPixData + 3] << 24);
+
+ line = (unsigned short *) malloc (2 * PixelWidth); // we need a buffer for a line
+ if (line == NULL) {
+ return(-4); // error no memory
+ }
+
+ // the bmp lines are padded to multiple of 4 bytes
+ padd = -1;
+ do {
+ padd ++;
+ } while ((PixelWidth * 2 + padd)%4 != 0);
+
+ window(x, y,PixelWidth ,PixelHeigh);
+ wr_cmd(0x2C); // send pixel
+ spi_16(1);
+ for (j = PixelHeigh - 1; j >= 0; j--) { //Lines bottom up
+ off = j * (PixelWidth * 2 + padd) + start_data; // start of line
+ fseek(Image, off ,SEEK_SET);
+ fread(line,1,PixelWidth * 2,Image); // read a line - slow
+ for (i = 0; i < PixelWidth; i++) { // copy pixel data to TFT
+ f_write(line[i]); // one 16 bit pixel
+ }
+ }
+ spi_bsy();
+ _cs = 1;
+ spi_16(0);
+ free (line);
+ fclose(Image);
+ WindowMax();
+ return(1);
+}
+
+#endif
+