alexey.zholtikov/upm
1
0
Fork 0
mirror of https://github.com/eclipse/upm.git synced 2025-03-15 04:57:30 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

st7735: Added text feature and documentation with license

Browse Source 
Signed-off-by: Kiveisha Yevgeniy <yevgeniy.kiveisha@intel.com>
This commit is contained in:
Kiveisha Yevgeniy 2014-06-16 12:32:59 +00:00
parent 2c1baf66b5
commit 8fe679494c
6 changed files with 617 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
examples/st7735.cxx
View File

@ -35,27 +35,42 @@ main(int argc, char **argv)
upm::ST7735 * lcd = new upm::ST7735(7, 4, 9, 8); upm::ST7735 * lcd = new upm::ST7735(7, 4, 9, 8);
lcd->fillScreen (ST7735_RED); lcd->fillScreen (ST7735_RED);
lcd->refresh (); lcd->refresh ();
lcd->fillScreen (ST7735_CYAN); lcd->fillScreen (ST7735_CYAN);
lcd->refresh (); lcd->refresh ();
lcd->fillScreen (ST7735_BLACK); lcd->fillScreen (ST7735_BLACK);
lcd->refresh (); lcd->refresh ();
lcd->drawLine(10, 10, 10, 100, ST7735_MAGENTA); lcd->drawLine(10, 10, 10, 100, ST7735_MAGENTA);
lcd->drawLine(20, 20, 10, 100, ST7735_YELLOW); lcd->drawLine(20, 20, 10, 100, ST7735_YELLOW);
lcd->drawLine(30, 30, 50, 100, ST7735_WHITE); lcd->drawLine(30, 30, 50, 100, ST7735_WHITE);
lcd->refresh (); lcd->refresh ();
lcd->drawPixel (20, 20, ST7735_GREEN); lcd->drawPixel (20, 20, ST7735_GREEN);
lcd->refresh (); lcd->refresh ();
lcd->drawTriangle (50, 50, 80, 80, 60, 90, ST7735_GREEN); lcd->drawTriangle (50, 50, 80, 80, 60, 90, ST7735_GREEN);
lcd->refresh (); lcd->refresh ();
lcd->drawCircle (100, 110, 10, ST7735_BLUE); lcd->drawCircle (100, 110, 10, ST7735_BLUE);
lcd->refresh (); lcd->refresh ();
lcd->setTextWrap(0x0);
lcd->setCursor(0, 30);
lcd->setTextColor(ST7735_RED, ST7735_RED);
lcd->setTextSize(1);
lcd->print("Hello World!");
lcd->setCursor(10, 50);
lcd->setTextColor(ST7735_RED, ST7735_YELLOW);
lcd->setTextSize(2);
lcd->print("BIG");
lcd->refresh ();
std::cout << "exiting application" << std::endl; std::cout << "exiting application" << std::endl;
delete lcd; delete lcd;

103
src/st7735/gfx.cxx
View File

@ -30,48 +30,50 @@
using namespace upm; using namespace upm;
GFX::GFX (int width, int height) { GFX::GFX (int width, int height, uint8_t * screenBuffer, const unsigned char * font) : WIDTH(width), HEIGHT(height) {
m_height = height; m_height = height;
m_width = width; m_width = width;
m_font = font;
m_map = screenBuffer;
} }
GFX::~GFX () { GFX::~GFX () {
} }
maa_result_t maa_result_t
GFX::setPixel (int x, int y, uint16_t color) { GFX::setPixel (int x, int y, uint16_t color) {
if((x < 0) ||(x >= m_width) || (y < 0) || (y >= m_height)) { if((x < 0) ||(x >= m_width) || (y < 0) || (y >= m_height)) {
return MAA_ERROR_UNSPECIFIED; return MAA_ERROR_UNSPECIFIED;
} }
int index = ((y * m_width) + x) * sizeof(uint16_t); int index = ((y * m_width) + x) * sizeof(uint16_t);
m_map[index] = (uint8_t) (color >> 8); m_map[index] = (uint8_t) (color >> 8);
m_map[++index] = (uint8_t)(color); m_map[++index] = (uint8_t)(color);
return MAA_SUCCESS; return MAA_SUCCESS;
} }
void void
GFX::fillScreen (uint16_t color) { GFX::fillScreen (uint16_t color) {
fillRect(0, 0, m_width, m_height, color); fillRect(0, 0, m_width, m_height, color);
} }
void void
GFX::fillRect (int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) { GFX::fillRect (int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) {
for (int16_t i=x; i<x+w; i++) { for (int16_t i=x; i<x+w; i++) {
drawFastVLine(i, y, h, color); drawFastVLine(i, y, h, color);
} }
} }
void void
GFX::drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) { GFX::drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) {
drawLine(x, y, x, y+h-1, color); drawLine(x, y, x, y+h-1, color);
} }
void void
GFX::drawLine (int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color) { GFX::drawLine (int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color) {
int16_t steep = abs(y1 - y0) > abs(x1 - x0); int16_t steep = abs(y1 - y0) > abs(x1 - x0);
if (steep) { if (steep) {
swap(x0, y0); swap(x0, y0);
swap(x1, y1); swap(x1, y1);
@ -109,14 +111,14 @@ GFX::drawLine (int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color) {
} }
} }
void void
GFX::drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) { GFX::drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
drawLine(x0, y0, x1, y1, color); drawLine(x0, y0, x1, y1, color);
drawLine(x1, y1, x2, y2, color); drawLine(x1, y1, x2, y2, color);
drawLine(x2, y2, x0, y0, color); drawLine(x2, y2, x0, y0, color);
} }
void void
GFX::drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color) { GFX::drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color) {
int16_t f = 1 - r; int16_t f = 1 - r;
int16_t ddF_x = 1; int16_t ddF_x = 1;
@ -136,7 +138,7 @@ GFX::drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color) {
f += ddF_y; f += ddF_y;
} }
x++; x++;
ddF_x += 2; ddF_x += 2;
f += ddF_x; f += ddF_x;
@ -150,3 +152,80 @@ GFX::drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color) {
setPixel(x0 - y, y0 - x, color); setPixel(x0 - y, y0 - x, color);
} }
} }
void
GFX::setCursor (int16_t x, int16_t y) {
m_cursorX = x;
m_cursorY = y;
}
void
GFX::setTextColor (uint16_t textColor, uint16_t textBGColor) {
m_textColor = textColor;
m_textBGColor = textBGColor;
}
void
GFX::setTextSize (uint8_t size) {
m_textSize = (size > 0) ? size : 1;
}
void
GFX::setTextWrap (uint8_t wrap) {
m_wrap = wrap;
}
void
GFX::drawChar (int16_t x, int16_t y, uint8_t data, uint16_t color, uint16_t bg, uint8_t size) {
if( (x >= m_width) || // Clip right
(y >= m_height) || // Clip bottom
((x + 6 * size - 1) < 0) || // Clip left
((y + 8 * size - 1) < 0)) // Clip top
return;
for (int8_t i=0; i<6; i++ ) {
uint8_t line;
if (i == 5) {
line = 0x0;
} else {
line = *(m_font+(data * 5)+i);
for (int8_t j = 0; j<8; j++) {
if (line & 0x1) {
if (size == 1) // default size
setPixel (x+i, y+j, color);
else { // big size
fillRect (x+(i*size), y+(j*size), size, size, color);
}
} else if (bg != color) {
if (size == 1) // default size
setPixel (x+i, y+j, bg);
else { // big size
fillRect (x+i*size, y+j*size, size, size, bg);
}
}
line >>= 1;
}
}
}
}
void
GFX::print (std::string msg) {
int len = msg.length();
for (int idx = 0; idx < len; idx++) {
if (msg[idx] == '\n') {
m_cursorY += m_textSize * 8;
m_cursorX = 0;
} else if (msg[idx] == '\r') {
// skip em
} else {
drawChar(m_cursorX, m_cursorY, msg[idx], m_textColor, m_textBGColor, m_textSize);
m_cursorX += m_textSize * 6;
if (m_wrap && (m_textColor > (m_width - m_textSize * 6))) {
m_cursorY += m_textSize * 8;
m_cursorX = 0;
}
}
}
}

156
src/st7735/gfx.h
View File

@ -32,7 +32,7 @@
#define swap(a, b) { int16_t t = a; a = b; b = t; } #define swap(a, b) { int16_t t = a; a = b; b = t; }
namespace upm { namespace upm {
/** /**
* @brief GFX helper class * @brief GFX helper class
* *
@ -43,10 +43,12 @@ class GFX {
/** /**
* Instanciates a GFX object * Instanciates a GFX object
* *
* @param width * @param width screen width
* @param height * @param height screen height
* @param screenBuffer pointer to screen buffer
* @param font pointer to font map
*/ */
GFX (int width, int height); GFX (int width, int height, uint8_t * screenBuffer, const unsigned char * font);
/** /**
* GFX object destructor * GFX object destructor
@ -62,55 +64,153 @@ class GFX {
* @param y1 second coordinate * @param y1 second coordinate
*/ */
virtual void setAddrWindow (uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1) = 0; virtual void setAddrWindow (uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1) = 0;
/** /**
* * Send pixel collor (RGB) to the chip. Must be implemented by
* inherited class.
*
* @param x axis on horizontal scale
* @param y axis on vertical scale
* @param color rgb value
*/ */
virtual void drawPixel (int16_t x, int16_t y, uint16_t color) = 0; virtual void drawPixel (int16_t x, int16_t y, uint16_t color) = 0;
/** /**
* * Copy the buffer to the chip via SPI interface.
*/ */
virtual void refresh () = 0; virtual void refresh () = 0;
/** /**
* *
*
* @param x axis on horizontal scale
* @param y axis on vertical scale
* @param data character to write
* @param color character's color
* @param bg character's background color
* @param size size of the font
*/
void drawChar (int16_t x, int16_t y, uint8_t data, uint16_t color, uint16_t bg, uint8_t size);
/**
* Print the message to the screen
*
* @param msg message which will be printed
*/
void print (std::string msg);
/**
* Print the message to the screen
*
* @param x axis on horizontal scale
* @param y axis on vertical scale
* @param color pixel's color
*/ */
maa_result_t setPixel (int x, int y, uint16_t color); maa_result_t setPixel (int x, int y, uint16_t color);
/** /**
* * Fill screen with selected color
*
* @param color selected's color
*/ */
void fillScreen (uint16_t color); void fillScreen (uint16_t color);
/** /**
* * Fill rectangle with selected color
*
* @param x axis on horizontal scale (top left corner)
* @param y axis on vertical scale (top left corner)
* @param w distanse from x
* @param h distanse from y
* @param color selected color
*/ */
void fillRect (int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color); void fillRect (int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
/** /**
* * Draw line in vertical scale.
*
* @param x axis on horizontal scale
* @param y axis on vertical scale
* @param h distanse from y
* @param color selected color
*/ */
void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color); void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
/** /**
* * Draw line from coordinate C0 to coordinate C1
*
* @param x0 first coordinate
* @param y0 first coordinate
* @param x1 second coordinate
* @param y1 second coordinate
* @param color selected color
*/ */
void drawLine (int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color); void drawLine (int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
/** /**
* * Draw a triangle
*
* @param x0 first coordinate
* @param y0 first coordinate
* @param x1 second coordinate
* @param y1 second coordinate
* @param x2 third coordinate
* @param y2 third coordinate
* @param color selected color
*/ */
void drawTriangle (int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color); void drawTriangle (int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color);
/** /**
* * Draw a circle
*
* @param x center of circule on X scale
* @param y center of circule on Y scale
*/ */
void drawCircle (int16_t x0, int16_t y0, int16_t r, uint16_t color); void drawCircle (int16_t x, int16_t y, int16_t r, uint16_t color);
int m_height; /**
int m_width; * Set cursor for text message
*
uint8_t m_map[160 * 128 * 2]; * @param x axis on horizontal scale
* @param y axis on vertical scale
*/
void setCursor (int16_t x, int16_t y);
/**
* Set text color for the message
*
* @param textColor font color
* @param textBGColor background color
*/
void setTextColor (uint16_t textColor, uint16_t textBGColor);
/**
* Set the size of the font
*
* @param size font size
*/
void setTextSize (uint8_t size);
/**
* Wrap printed message.
*
* @param wrap true (0x1) or false (0x0)
*/
void setTextWrap (uint8_t wrap);
int m_height; /**< Screen height */
int m_width; /**< Screen width */
int m_textSize; /**< Printed text size */
int m_textColor; /**< Printed text color */
int m_textBGColor; /**< Printed text background color */
int m_cursorX; /**< Cursor X coordinate */
int m_cursorY; /**< Cursor Y coordinate */
int m_wrap; /**< Wrapper flag (true or false) */
uint8_t * m_map; /**< Screens buffer */
protected:
const int16_t WIDTH, HEIGHT;
const unsigned char * m_font;
}; };
} }

24
src/st7735/license.txt Normal file
View File

@ -0,0 +1,24 @@
Software License Agreement (BSD License)
Copyright (c) 2012 Adafruit Industries. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

104
src/st7735/st7735.cxx
View File

@ -32,14 +32,14 @@
using namespace upm; using namespace upm;
ST7735::ST7735 (uint8_t csLCD, uint8_t cSD, uint8_t rs, uint8_t rst) : GFX (160, 128) { ST7735::ST7735 (uint8_t csLCD, uint8_t cSD, uint8_t rs, uint8_t rst) : GFX (160, 128, m_map, font) {
maa_init(); maa_init();
m_csLCD = csLCD; m_csLCD = csLCD;
m_cSD = cSD; m_cSD = cSD;
m_rST = rst; m_rST = rst;
m_rS = rs; m_rS = rs;
initModule (); initModule ();
configModule (); configModule ();
} }
@ -71,7 +71,7 @@ ST7735::~ST7735 () {
void void
ST7735::initModule () { ST7735::initModule () {
maa_result_t error = MAA_SUCCESS; maa_result_t error = MAA_SUCCESS;
m_height = 160; m_height = 160;
m_width = 128; m_width = 128;
@ -86,13 +86,13 @@ ST7735::initModule () {
fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", m_cSD); fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", m_cSD);
exit (1); exit (1);
} }
m_rSTPinCtx = maa_gpio_init (m_rST); m_rSTPinCtx = maa_gpio_init (m_rST);
if (m_rSTPinCtx == NULL) { if (m_rSTPinCtx == NULL) {
fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", m_rST); fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", m_rST);
exit (1); exit (1);
} }
m_rSPinCtx = maa_gpio_init (m_rS); m_rSPinCtx = maa_gpio_init (m_rS);
if (m_rSPinCtx == NULL) { if (m_rSPinCtx == NULL) {
fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", m_rS); fprintf (stderr, "Are you sure that pin%d you requested is valid on your platform?", m_rS);
@ -108,12 +108,12 @@ ST7735::initModule () {
if (error != MAA_SUCCESS) { if (error != MAA_SUCCESS) {
maa_result_print (error); maa_result_print (error);
} }
error = maa_gpio_dir (m_rSTPinCtx, MAA_GPIO_OUT); error = maa_gpio_dir (m_rSTPinCtx, MAA_GPIO_OUT);
if (error != MAA_SUCCESS) { if (error != MAA_SUCCESS) {
maa_result_print (error); maa_result_print (error);
} }
error = maa_gpio_dir (m_rSPinCtx, MAA_GPIO_OUT); error = maa_gpio_dir (m_rSPinCtx, MAA_GPIO_OUT);
if (error != MAA_SUCCESS) { if (error != MAA_SUCCESS) {
maa_result_print (error); maa_result_print (error);
@ -124,7 +124,7 @@ ST7735::initModule () {
if (error != MAA_SUCCESS) { if (error != MAA_SUCCESS) {
maa_result_print (error); maa_result_print (error);
} }
lcdCSOn (); lcdCSOn ();
} }
@ -140,7 +140,7 @@ ST7735::data (uint8_t value) {
maa_spi_write (m_spi, value); maa_spi_write (m_spi, value);
} }
void void
ST7735::executeCMDList(const uint8_t *addr) { ST7735::executeCMDList(const uint8_t *addr) {
uint8_t numCommands, numArgs; uint8_t numCommands, numArgs;
uint16_t ms; uint16_t ms;
@ -165,45 +165,45 @@ ST7735::executeCMDList(const uint8_t *addr) {
} }
} }
void void
ST7735::setAddrWindow(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1) { ST7735::setAddrWindow(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1) {
uint8_t colstart, rowstart; uint8_t colstart, rowstart;
colstart = rowstart = 0; colstart = rowstart = 0;
write (ST7735_CASET); // Column addr set write (ST7735_CASET); // Column addr set
rsHIGH (); rsHIGH ();
m_spiBuffer[0] = 0x00; m_spiBuffer[0] = 0x00;
m_spiBuffer[1] = x0 + colstart; // XSTART m_spiBuffer[1] = x0 + colstart; // XSTART
m_spiBuffer[2] = 0x00; m_spiBuffer[2] = 0x00;
m_spiBuffer[3] = x1 + colstart; // XEND m_spiBuffer[3] = x1 + colstart; // XEND
maa_spi_write_buf(m_spi, m_spiBuffer, 4); maa_spi_write_buf(m_spi, m_spiBuffer, 4);
write (ST7735_RASET); // Row addr set write (ST7735_RASET); // Row addr set
rsHIGH (); rsHIGH ();
m_spiBuffer[0] = 0x00; m_spiBuffer[0] = 0x00;
m_spiBuffer[1] = y0 + rowstart; // YSTART m_spiBuffer[1] = y0 + rowstart; // YSTART
m_spiBuffer[2] = 0x00; m_spiBuffer[2] = 0x00;
m_spiBuffer[3] = y1 + rowstart; // YEND m_spiBuffer[3] = y1 + rowstart; // YEND
maa_spi_write_buf(m_spi, m_spiBuffer, 4); maa_spi_write_buf(m_spi, m_spiBuffer, 4);
write (ST7735_RAMWR); // write to RAM write (ST7735_RAMWR); // write to RAM
} }
void void
ST7735::drawPixel(int16_t x, int16_t y, uint16_t color) { ST7735::drawPixel(int16_t x, int16_t y, uint16_t color) {
if (MAA_SUCCESS != setPixel (x, y, color)) { if (MAA_SUCCESS != setPixel (x, y, color)) {
return; return;
} }
refresh (); refresh ();
} }
void void
ST7735::refresh () { ST7735::refresh () {
rsHIGH (); rsHIGH ();
int fragmentSize = m_height * m_width * 2 / 20; int fragmentSize = m_height * m_width * 2 / 20;
for (int fragment = 0; fragment < 20; fragment++) { for (int fragment = 0; fragment < 20; fragment++) {
maa_spi_write_buf(m_spi, &m_map[fragment * fragmentSize], fragmentSize); maa_spi_write_buf(m_spi, &m_map[fragment * fragmentSize], fragmentSize);
@ -215,72 +215,36 @@ ST7735::configModule() {
rsHIGH (); rsHIGH ();
lcdCSOff (); lcdCSOff ();
lcdCSOn (); lcdCSOn ();
maa_gpio_write (m_rSTPinCtx, HIGH); maa_gpio_write (m_rSTPinCtx, HIGH);
usleep (500000); usleep (500000);
maa_gpio_write (m_rSTPinCtx, LOW); maa_gpio_write (m_rSTPinCtx, LOW);
usleep (500000); usleep (500000);
maa_gpio_write (m_rSTPinCtx, HIGH); maa_gpio_write (m_rSTPinCtx, HIGH);
usleep (500000); usleep (500000);
executeCMDList (Rcmd1); executeCMDList (Rcmd1);
executeCMDList (Rcmd2red); executeCMDList (Rcmd2red);
executeCMDList (Rcmd3); executeCMDList (Rcmd3);
write (ST7735_MADCTL); write (ST7735_MADCTL);
data (0xC0); data (0xC0);
setAddrWindow (0, 0, m_width - 1, m_height - 1); setAddrWindow (0, 0, m_width - 1, m_height - 1);
fillScreen (ST7735_BLACK); fillScreen (ST7735_BLACK);
refresh (); refresh ();
} }
void
ST7735::fill (int col, uint16_t* buff, int len) {
uint8_t colstart, rowstart;
uint8_t buf[len * 2];
colstart = 0;
write (ST7735_CASET); // Column addr set
rsHIGH ();
m_spiBuffer[0] = 0x00;
m_spiBuffer[1] = col + 1; // XSTART
m_spiBuffer[2] = 0x00;
m_spiBuffer[3] = col + 1; // XEND
maa_spi_write_buf(m_spi, m_spiBuffer, 4);
write (ST7735_RASET); // Row addr set
rsHIGH ();
m_spiBuffer[0] = 0x00;
m_spiBuffer[1] = 0x01; // YSTART
m_spiBuffer[2] = 0x00;
m_spiBuffer[3] = 0x9F; // YEND
maa_spi_write_buf(m_spi, m_spiBuffer, 4);
write (ST7735_RAMWR); // write to RAM
/*for (int idx = 0; idx < len; idx++) {
buf[idx*2] = buff[idx] >> 8;
buf[(idx*2)+1] = buff[idx];
}*/
rsHIGH ();
maa_spi_write_buf(m_spi, (uint8_t *)buff, len * 2);
}
maa_result_t maa_result_t
ST7735::lcdCSOn () { ST7735::lcdCSOn () {
maa_result_t error = MAA_SUCCESS; maa_result_t error = MAA_SUCCESS;
error = maa_gpio_write (m_csLCDPinCtx, LOW); error = maa_gpio_write (m_csLCDPinCtx, LOW);
if (error != MAA_SUCCESS) { if (error != MAA_SUCCESS) {
maa_result_print (error); maa_result_print (error);
} }
error = maa_gpio_write (m_cSDPinCtx, HIGH); error = maa_gpio_write (m_cSDPinCtx, HIGH);
if (error != MAA_SUCCESS) { if (error != MAA_SUCCESS) {
maa_result_print (error); maa_result_print (error);
@ -292,7 +256,7 @@ ST7735::lcdCSOn () {
maa_result_t maa_result_t
ST7735::lcdCSOff () { ST7735::lcdCSOff () {
maa_result_t error = MAA_SUCCESS; maa_result_t error = MAA_SUCCESS;
error = maa_gpio_write (m_csLCDPinCtx, HIGH); error = maa_gpio_write (m_csLCDPinCtx, HIGH);
if (error != MAA_SUCCESS) { if (error != MAA_SUCCESS) {
maa_result_print (error); maa_result_print (error);
@ -304,12 +268,12 @@ ST7735::lcdCSOff () {
maa_result_t maa_result_t
ST7735::sdCSOn () { ST7735::sdCSOn () {
maa_result_t error = MAA_SUCCESS; maa_result_t error = MAA_SUCCESS;
error = maa_gpio_write (m_cSDPinCtx, LOW); error = maa_gpio_write (m_cSDPinCtx, LOW);
if (error != MAA_SUCCESS) { if (error != MAA_SUCCESS) {
maa_result_print (error); maa_result_print (error);
} }
error = maa_gpio_write (m_csLCDPinCtx, HIGH); error = maa_gpio_write (m_csLCDPinCtx, HIGH);
if (error != MAA_SUCCESS) { if (error != MAA_SUCCESS) {
maa_result_print (error); maa_result_print (error);
@ -321,7 +285,7 @@ ST7735::sdCSOn () {
maa_result_t maa_result_t
ST7735::sdCSOff () { ST7735::sdCSOff () {
maa_result_t error = MAA_SUCCESS; maa_result_t error = MAA_SUCCESS;
error = maa_gpio_write (m_cSDPinCtx, HIGH); error = maa_gpio_write (m_cSDPinCtx, HIGH);
if (error != MAA_SUCCESS) { if (error != MAA_SUCCESS) {
maa_result_print (error); maa_result_print (error);
@ -333,7 +297,7 @@ ST7735::sdCSOff () {
maa_result_t maa_result_t
ST7735::rsHIGH () { ST7735::rsHIGH () {
maa_result_t error = MAA_SUCCESS; maa_result_t error = MAA_SUCCESS;
error = maa_gpio_write (m_rSPinCtx, HIGH); error = maa_gpio_write (m_rSPinCtx, HIGH);
if (error != MAA_SUCCESS) { if (error != MAA_SUCCESS) {
maa_result_print (error); maa_result_print (error);
@ -345,7 +309,7 @@ ST7735::rsHIGH () {
maa_result_t maa_result_t
ST7735::rsLOW () { ST7735::rsLOW () {
maa_result_t error = MAA_SUCCESS; maa_result_t error = MAA_SUCCESS;
error = maa_gpio_write (m_rSPinCtx, LOW); error = maa_gpio_write (m_rSPinCtx, LOW);
if (error != MAA_SUCCESS) { if (error != MAA_SUCCESS) {
maa_result_print (error); maa_result_print (error);

363
src/st7735/st7735.h
View File

@ -2,10 +2,9 @@
* Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com> * Author: Yevgeniy Kiveisha <yevgeniy.kiveisha@intel.com>
* Copyright (c) 2014 Intel Corporation. * Copyright (c) 2014 Intel Corporation.
* *
* Credits to Adafrut.com * Credits to Adafruit.
* {Based on,Inspired from} original <libname> from <author>. See original license in <filepath>. * Based on Adafruit ST7735 library, see original license in license.txt file.
*
*
* Permission is hereby granted, free of charge, to any person obtaining * Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the * a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including * "Software"), to deal in the Software without restriction, including
@ -87,13 +86,13 @@
#define ST7735_GMCTRN1 0xE1 #define ST7735_GMCTRN1 0xE1
// Color definitions // Color definitions
#define ST7735_BLACK 0x0000 #define ST7735_BLACK 0x0000
#define ST7735_BLUE 0x001F #define ST7735_BLUE 0x001F
#define ST7735_RED 0xF800 #define ST7735_RED 0xF800
#define ST7735_GREEN 0x07E0 #define ST7735_GREEN 0x07E0
#define ST7735_CYAN 0x07FF #define ST7735_CYAN 0x07FF
#define ST7735_MAGENTA 0xF81F #define ST7735_MAGENTA 0xF81F
#define ST7735_YELLOW 0xFFE0 #define ST7735_YELLOW 0xFFE0
#define ST7735_WHITE 0xFFFF #define ST7735_WHITE 0xFFFF
#define HIGH 1 #define HIGH 1
@ -103,7 +102,7 @@
namespace upm { namespace upm {
static const uint8_t Bcmd[] = { static const uint8_t Bcmd[] = {
// Initialization commands for 7735B screens // Initialization commands for 7735B screens
18, // 18 commands in list: 18, // 18 commands in list:
ST7735_SWRESET, DELAY, // 1: Software reset, no args, w/delay ST7735_SWRESET, DELAY, // 1: Software reset, no args, w/delay
@ -189,7 +188,7 @@ static const uint8_t Bcmd[] = {
0x00, // Boost frequency 0x00, // Boost frequency
ST7735_PWCTR4 , 2 , // 10: Power control, 2 args, no delay: ST7735_PWCTR4 , 2 , // 10: Power control, 2 args, no delay:
0x8A, // BCLK/2, Opamp current small & Medium low 0x8A, // BCLK/2, Opamp current small & Medium low
0x2A, 0x2A,
ST7735_PWCTR5 , 2 , // 11: Power control, 2 args, no delay: ST7735_PWCTR5 , 2 , // 11: Power control, 2 args, no delay:
0x8A, 0xEE, 0x8A, 0xEE,
ST7735_VMCTR1 , 1 , // 12: Power control, 1 arg, no delay: ST7735_VMCTR1 , 1 , // 12: Power control, 1 arg, no delay:
@ -236,27 +235,285 @@ static const uint8_t Bcmd[] = {
#define swap(a, b) { int16_t t = a; a = b; b = t; } #define swap(a, b) { int16_t t = a; a = b; b = t; }
const unsigned char font[] = {
0x00, 0x00, 0x00, 0x00, 0x00,
0x3E, 0x5B, 0x4F, 0x5B, 0x3E,
0x3E, 0x6B, 0x4F, 0x6B, 0x3E,
0x1C, 0x3E, 0x7C, 0x3E, 0x1C,
0x18, 0x3C, 0x7E, 0x3C, 0x18,
0x1C, 0x57, 0x7D, 0x57, 0x1C,
0x1C, 0x5E, 0x7F, 0x5E, 0x1C,
0x00, 0x18, 0x3C, 0x18, 0x00,
0xFF, 0xE7, 0xC3, 0xE7, 0xFF,
0x00, 0x18, 0x24, 0x18, 0x00,
0xFF, 0xE7, 0xDB, 0xE7, 0xFF,
0x30, 0x48, 0x3A, 0x06, 0x0E,
0x26, 0x29, 0x79, 0x29, 0x26,
0x40, 0x7F, 0x05, 0x05, 0x07,
0x40, 0x7F, 0x05, 0x25, 0x3F,
0x5A, 0x3C, 0xE7, 0x3C, 0x5A,
0x7F, 0x3E, 0x1C, 0x1C, 0x08,
0x08, 0x1C, 0x1C, 0x3E, 0x7F,
0x14, 0x22, 0x7F, 0x22, 0x14,
0x5F, 0x5F, 0x00, 0x5F, 0x5F,
0x06, 0x09, 0x7F, 0x01, 0x7F,
0x00, 0x66, 0x89, 0x95, 0x6A,
0x60, 0x60, 0x60, 0x60, 0x60,
0x94, 0xA2, 0xFF, 0xA2, 0x94,
0x08, 0x04, 0x7E, 0x04, 0x08,
0x10, 0x20, 0x7E, 0x20, 0x10,
0x08, 0x08, 0x2A, 0x1C, 0x08,
0x08, 0x1C, 0x2A, 0x08, 0x08,
0x1E, 0x10, 0x10, 0x10, 0x10,
0x0C, 0x1E, 0x0C, 0x1E, 0x0C,
0x30, 0x38, 0x3E, 0x38, 0x30,
0x06, 0x0E, 0x3E, 0x0E, 0x06,
0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x5F, 0x00, 0x00,
0x00, 0x07, 0x00, 0x07, 0x00,
0x14, 0x7F, 0x14, 0x7F, 0x14,
0x24, 0x2A, 0x7F, 0x2A, 0x12,
0x23, 0x13, 0x08, 0x64, 0x62,
0x36, 0x49, 0x56, 0x20, 0x50,
0x00, 0x08, 0x07, 0x03, 0x00,
0x00, 0x1C, 0x22, 0x41, 0x00,
0x00, 0x41, 0x22, 0x1C, 0x00,
0x2A, 0x1C, 0x7F, 0x1C, 0x2A,
0x08, 0x08, 0x3E, 0x08, 0x08,
0x00, 0x80, 0x70, 0x30, 0x00,
0x08, 0x08, 0x08, 0x08, 0x08,
0x00, 0x00, 0x60, 0x60, 0x00,
0x20, 0x10, 0x08, 0x04, 0x02,
0x3E, 0x51, 0x49, 0x45, 0x3E,
0x00, 0x42, 0x7F, 0x40, 0x00,
0x72, 0x49, 0x49, 0x49, 0x46,
0x21, 0x41, 0x49, 0x4D, 0x33,
0x18, 0x14, 0x12, 0x7F, 0x10,
0x27, 0x45, 0x45, 0x45, 0x39,
0x3C, 0x4A, 0x49, 0x49, 0x31,
0x41, 0x21, 0x11, 0x09, 0x07,
0x36, 0x49, 0x49, 0x49, 0x36,
0x46, 0x49, 0x49, 0x29, 0x1E,
0x00, 0x00, 0x14, 0x00, 0x00,
0x00, 0x40, 0x34, 0x00, 0x00,
0x00, 0x08, 0x14, 0x22, 0x41,
0x14, 0x14, 0x14, 0x14, 0x14,
0x00, 0x41, 0x22, 0x14, 0x08,
0x02, 0x01, 0x59, 0x09, 0x06,
0x3E, 0x41, 0x5D, 0x59, 0x4E,
0x7C, 0x12, 0x11, 0x12, 0x7C,
0x7F, 0x49, 0x49, 0x49, 0x36,
0x3E, 0x41, 0x41, 0x41, 0x22,
0x7F, 0x41, 0x41, 0x41, 0x3E,
0x7F, 0x49, 0x49, 0x49, 0x41,
0x7F, 0x09, 0x09, 0x09, 0x01,
0x3E, 0x41, 0x41, 0x51, 0x73,
0x7F, 0x08, 0x08, 0x08, 0x7F,
0x00, 0x41, 0x7F, 0x41, 0x00,
0x20, 0x40, 0x41, 0x3F, 0x01,
0x7F, 0x08, 0x14, 0x22, 0x41,
0x7F, 0x40, 0x40, 0x40, 0x40,
0x7F, 0x02, 0x1C, 0x02, 0x7F,
0x7F, 0x04, 0x08, 0x10, 0x7F,
0x3E, 0x41, 0x41, 0x41, 0x3E,
0x7F, 0x09, 0x09, 0x09, 0x06,
0x3E, 0x41, 0x51, 0x21, 0x5E,
0x7F, 0x09, 0x19, 0x29, 0x46,
0x26, 0x49, 0x49, 0x49, 0x32,
0x03, 0x01, 0x7F, 0x01, 0x03,
0x3F, 0x40, 0x40, 0x40, 0x3F,
0x1F, 0x20, 0x40, 0x20, 0x1F,
0x3F, 0x40, 0x38, 0x40, 0x3F,
0x63, 0x14, 0x08, 0x14, 0x63,
0x03, 0x04, 0x78, 0x04, 0x03,
0x61, 0x59, 0x49, 0x4D, 0x43,
0x00, 0x7F, 0x41, 0x41, 0x41,
0x02, 0x04, 0x08, 0x10, 0x20,
0x00, 0x41, 0x41, 0x41, 0x7F,
0x04, 0x02, 0x01, 0x02, 0x04,
0x40, 0x40, 0x40, 0x40, 0x40,
0x00, 0x03, 0x07, 0x08, 0x00,
0x20, 0x54, 0x54, 0x78, 0x40,
0x7F, 0x28, 0x44, 0x44, 0x38,
0x38, 0x44, 0x44, 0x44, 0x28,
0x38, 0x44, 0x44, 0x28, 0x7F,
0x38, 0x54, 0x54, 0x54, 0x18,
0x00, 0x08, 0x7E, 0x09, 0x02,
0x18, 0xA4, 0xA4, 0x9C, 0x78,
0x7F, 0x08, 0x04, 0x04, 0x78,
0x00, 0x44, 0x7D, 0x40, 0x00,
0x20, 0x40, 0x40, 0x3D, 0x00,
0x7F, 0x10, 0x28, 0x44, 0x00,
0x00, 0x41, 0x7F, 0x40, 0x00,
0x7C, 0x04, 0x78, 0x04, 0x78,
0x7C, 0x08, 0x04, 0x04, 0x78,
0x38, 0x44, 0x44, 0x44, 0x38,
0xFC, 0x18, 0x24, 0x24, 0x18,
0x18, 0x24, 0x24, 0x18, 0xFC,
0x7C, 0x08, 0x04, 0x04, 0x08,
0x48, 0x54, 0x54, 0x54, 0x24,
0x04, 0x04, 0x3F, 0x44, 0x24,
0x3C, 0x40, 0x40, 0x20, 0x7C,
0x1C, 0x20, 0x40, 0x20, 0x1C,
0x3C, 0x40, 0x30, 0x40, 0x3C,
0x44, 0x28, 0x10, 0x28, 0x44,
0x4C, 0x90, 0x90, 0x90, 0x7C,
0x44, 0x64, 0x54, 0x4C, 0x44,
0x00, 0x08, 0x36, 0x41, 0x00,
0x00, 0x00, 0x77, 0x00, 0x00,
0x00, 0x41, 0x36, 0x08, 0x00,
0x02, 0x01, 0x02, 0x04, 0x02,
0x3C, 0x26, 0x23, 0x26, 0x3C,
0x1E, 0xA1, 0xA1, 0x61, 0x12,
0x3A, 0x40, 0x40, 0x20, 0x7A,
0x38, 0x54, 0x54, 0x55, 0x59,
0x21, 0x55, 0x55, 0x79, 0x41,
0x21, 0x54, 0x54, 0x78, 0x41,
0x21, 0x55, 0x54, 0x78, 0x40,
0x20, 0x54, 0x55, 0x79, 0x40,
0x0C, 0x1E, 0x52, 0x72, 0x12,
0x39, 0x55, 0x55, 0x55, 0x59,
0x39, 0x54, 0x54, 0x54, 0x59,
0x39, 0x55, 0x54, 0x54, 0x58,
0x00, 0x00, 0x45, 0x7C, 0x41,
0x00, 0x02, 0x45, 0x7D, 0x42,
0x00, 0x01, 0x45, 0x7C, 0x40,
0xF0, 0x29, 0x24, 0x29, 0xF0,
0xF0, 0x28, 0x25, 0x28, 0xF0,
0x7C, 0x54, 0x55, 0x45, 0x00,
0x20, 0x54, 0x54, 0x7C, 0x54,
0x7C, 0x0A, 0x09, 0x7F, 0x49,
0x32, 0x49, 0x49, 0x49, 0x32,
0x32, 0x48, 0x48, 0x48, 0x32,
0x32, 0x4A, 0x48, 0x48, 0x30,
0x3A, 0x41, 0x41, 0x21, 0x7A,
0x3A, 0x42, 0x40, 0x20, 0x78,
0x00, 0x9D, 0xA0, 0xA0, 0x7D,
0x39, 0x44, 0x44, 0x44, 0x39,
0x3D, 0x40, 0x40, 0x40, 0x3D,
0x3C, 0x24, 0xFF, 0x24, 0x24,
0x48, 0x7E, 0x49, 0x43, 0x66,
0x2B, 0x2F, 0xFC, 0x2F, 0x2B,
0xFF, 0x09, 0x29, 0xF6, 0x20,
0xC0, 0x88, 0x7E, 0x09, 0x03,
0x20, 0x54, 0x54, 0x79, 0x41,
0x00, 0x00, 0x44, 0x7D, 0x41,
0x30, 0x48, 0x48, 0x4A, 0x32,
0x38, 0x40, 0x40, 0x22, 0x7A,
0x00, 0x7A, 0x0A, 0x0A, 0x72,
0x7D, 0x0D, 0x19, 0x31, 0x7D,
0x26, 0x29, 0x29, 0x2F, 0x28,
0x26, 0x29, 0x29, 0x29, 0x26,
0x30, 0x48, 0x4D, 0x40, 0x20,
0x38, 0x08, 0x08, 0x08, 0x08,
0x08, 0x08, 0x08, 0x08, 0x38,
0x2F, 0x10, 0xC8, 0xAC, 0xBA,
0x2F, 0x10, 0x28, 0x34, 0xFA,
0x00, 0x00, 0x7B, 0x00, 0x00,
0x08, 0x14, 0x2A, 0x14, 0x22,
0x22, 0x14, 0x2A, 0x14, 0x08,
0xAA, 0x00, 0x55, 0x00, 0xAA,
0xAA, 0x55, 0xAA, 0x55, 0xAA,
0x00, 0x00, 0x00, 0xFF, 0x00,
0x10, 0x10, 0x10, 0xFF, 0x00,
0x14, 0x14, 0x14, 0xFF, 0x00,
0x10, 0x10, 0xFF, 0x00, 0xFF,
0x10, 0x10, 0xF0, 0x10, 0xF0,
0x14, 0x14, 0x14, 0xFC, 0x00,
0x14, 0x14, 0xF7, 0x00, 0xFF,
0x00, 0x00, 0xFF, 0x00, 0xFF,
0x14, 0x14, 0xF4, 0x04, 0xFC,
0x14, 0x14, 0x17, 0x10, 0x1F,
0x10, 0x10, 0x1F, 0x10, 0x1F,
0x14, 0x14, 0x14, 0x1F, 0x00,
0x10, 0x10, 0x10, 0xF0, 0x00,
0x00, 0x00, 0x00, 0x1F, 0x10,
0x10, 0x10, 0x10, 0x1F, 0x10,
0x10, 0x10, 0x10, 0xF0, 0x10,
0x00, 0x00, 0x00, 0xFF, 0x10,
0x10, 0x10, 0x10, 0x10, 0x10,
0x10, 0x10, 0x10, 0xFF, 0x10,
0x00, 0x00, 0x00, 0xFF, 0x14,
0x00, 0x00, 0xFF, 0x00, 0xFF,
0x00, 0x00, 0x1F, 0x10, 0x17,
0x00, 0x00, 0xFC, 0x04, 0xF4,
0x14, 0x14, 0x17, 0x10, 0x17,
0x14, 0x14, 0xF4, 0x04, 0xF4,
0x00, 0x00, 0xFF, 0x00, 0xF7,
0x14, 0x14, 0x14, 0x14, 0x14,
0x14, 0x14, 0xF7, 0x00, 0xF7,
0x14, 0x14, 0x14, 0x17, 0x14,
0x10, 0x10, 0x1F, 0x10, 0x1F,
0x14, 0x14, 0x14, 0xF4, 0x14,
0x10, 0x10, 0xF0, 0x10, 0xF0,
0x00, 0x00, 0x1F, 0x10, 0x1F,
0x00, 0x00, 0x00, 0x1F, 0x14,
0x00, 0x00, 0x00, 0xFC, 0x14,
0x00, 0x00, 0xF0, 0x10, 0xF0,
0x10, 0x10, 0xFF, 0x10, 0xFF,
0x14, 0x14, 0x14, 0xFF, 0x14,
0x10, 0x10, 0x10, 0x1F, 0x00,
0x00, 0x00, 0x00, 0xF0, 0x10,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
0xFF, 0xFF, 0xFF, 0x00, 0x00,
0x00, 0x00, 0x00, 0xFF, 0xFF,
0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
0x38, 0x44, 0x44, 0x38, 0x44,
0x7C, 0x2A, 0x2A, 0x3E, 0x14,
0x7E, 0x02, 0x02, 0x06, 0x06,
0x02, 0x7E, 0x02, 0x7E, 0x02,
0x63, 0x55, 0x49, 0x41, 0x63,
0x38, 0x44, 0x44, 0x3C, 0x04,
0x40, 0x7E, 0x20, 0x1E, 0x20,
0x06, 0x02, 0x7E, 0x02, 0x02,
0x99, 0xA5, 0xE7, 0xA5, 0x99,
0x1C, 0x2A, 0x49, 0x2A, 0x1C,
0x4C, 0x72, 0x01, 0x72, 0x4C,
0x30, 0x4A, 0x4D, 0x4D, 0x30,
0x30, 0x48, 0x78, 0x48, 0x30,
0xBC, 0x62, 0x5A, 0x46, 0x3D,
0x3E, 0x49, 0x49, 0x49, 0x00,
0x7E, 0x01, 0x01, 0x01, 0x7E,
0x2A, 0x2A, 0x2A, 0x2A, 0x2A,
0x44, 0x44, 0x5F, 0x44, 0x44,
0x40, 0x51, 0x4A, 0x44, 0x40,
0x40, 0x44, 0x4A, 0x51, 0x40,
0x00, 0x00, 0xFF, 0x01, 0x03,
0xE0, 0x80, 0xFF, 0x00, 0x00,
0x08, 0x08, 0x6B, 0x6B, 0x08,
0x36, 0x12, 0x36, 0x24, 0x36,
0x06, 0x0F, 0x09, 0x0F, 0x06,
0x00, 0x00, 0x18, 0x18, 0x00,
0x00, 0x00, 0x10, 0x10, 0x00,
0x30, 0x40, 0xFF, 0x01, 0x01,
0x00, 0x1F, 0x01, 0x01, 0x1E,
0x00, 0x19, 0x1D, 0x17, 0x12,
0x00, 0x3C, 0x3C, 0x3C, 0x3C,
0x00, 0x00, 0x00, 0x00, 0x00
};
/** /**
* @brief C++ API for NRF24l01 transceiver module * @brief C++ API for ST7735 SPI LCD module
* *
* This file defines the NRF24l01 C++ interface for libnrf24l01 * This file defines the ST7735 C++ interface for libst7735
* *
* @snippet nrf_receiver.cxx Interesting * @snippet st7735.cxx Interesting
* @snippet nrf_transmitter.cxx Interesting
*/ */
class ST7735 : public GFX { class ST7735 : public GFX {
public: public:
/** /**
* Instanciates a NRF24l01 object * Instanciates a ST7735 object
* *
* @param cs chip select pin * @param csLCD LCD chip select pin
* @param cSD SD card chip select pin
* @param rs data/command pin
* @param rst reset pin
*/ */
ST7735 (uint8_t csLCD, uint8_t cSD, uint8_t rs, uint8_t rst); ST7735 (uint8_t csLCD, uint8_t cSD, uint8_t rs, uint8_t rst);
/** /**
* NRF24l01 object destructor * ST7735 object destructor
*/ */
~ST7735 (); ~ST7735 ();
@ -269,76 +526,92 @@ class ST7735 : public GFX {
} }
/** /**
* * Initialize the modules GPIOs
*/ */
void initModule (); void initModule ();
/** /**
* * Configure the chip via SPI interface
*/ */
void configModule (); void configModule ();
/** /**
* * Send command to SPI bus (rs must be LOW)
*
* @param value command number
*/ */
void write (uint8_t value); void write (uint8_t value);
/** /**
* * Send data to SPI bus (rs must be HIGH)
*
* @param value command number
*/ */
void data (uint8_t value); void data (uint8_t value);
/** /**
* * Execute set of commands and data
*
* @param *addr pointer to start of the commands/data section
*/ */
void executeCMDList (const uint8_t *addr); void executeCMDList (const uint8_t *addr);
/** /**
* * Set the window size inside the screen where the pixels data
* will be written.
*
* @param x0 first coordinate
* @param y0 first coordinate
* @param x1 second coordinate
* @param y1 second coordinate
*/ */
void setAddrWindow (uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1); void setAddrWindow (uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1);
/** /**
* * Send pixel collor (RGB) to the chip.
*
* @param x axis on horizontal scale
* @param y axis on vertical scale
* @param color rgb (16bit) color (R[0-4], G[5-10], B[11-15])
*/ */
void drawPixel (int16_t x, int16_t y, uint16_t color); void drawPixel (int16_t x, int16_t y, uint16_t color);
/** /**
* * Copy the buffer to the chip via SPI interface.
*/ */
void refresh (); void refresh ();
/** /**
* * LCD chip select LOW.
*/ */
maa_result_t lcdCSOn (); maa_result_t lcdCSOn ();
/** /**
* * LCD chip select HIGH.
*/ */
maa_result_t lcdCSOff (); maa_result_t lcdCSOff ();
/** /**
* * CD card chip select LOW.
*/ */
maa_result_t sdCSOn (); maa_result_t sdCSOn ();
/** /**
* * CD card select HIGH.
*/ */
maa_result_t sdCSOff (); maa_result_t sdCSOff ();
/** /**
* * Data select HIGH.
*/ */
maa_result_t rsHIGH (); maa_result_t rsHIGH ();
/** /**
* * Data select LOW.
*/ */
maa_result_t rsLOW (); maa_result_t rsLOW ();
void fill (int col, uint16_t* buff, int len); uint8_t m_map[160 * 128 * 2]; /**< Screens buffer */
private: private:
maa_spi_context m_spi; maa_spi_context m_spi;
uint8_t m_csLCD; uint8_t m_csLCD;
@ -350,8 +623,8 @@ class ST7735 : public GFX {
maa_gpio_context m_cSDPinCtx; maa_gpio_context m_cSDPinCtx;
maa_gpio_context m_rSTPinCtx; maa_gpio_context m_rSTPinCtx;
maa_gpio_context m_rSPinCtx; maa_gpio_context m_rSPinCtx;
uint8_t m_spiBuffer[128]; uint8_t m_spiBuffer[32];
std::string m_name; std::string m_name;
}; };