Guillermo Stedile
Forked para SNOCC
Diff: RA8875.cpp
- Revision:
- 19:3f82c1161fd2
- Child:
- 20:6e2e4a8372eb
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/RA8875.cpp Sun Jan 12 17:40:32 2014 +0000
@@ -0,0 +1,842 @@
+/// RA8875 Display Controller Library.
+///
+/// This is being created for a specific display from buydisplay.com,
+/// which is 480 x xxx. It has other attributes (like display controller
+/// managed backlight brightness. So, there are expectations and some
+/// defined constants based on that specific display.
+///
+#include "RA8875.h"
+
+//#define DEBUG "RAIO"
+// ...
+// INFO("Stuff to show %d", var); // new-line is automatically appended
+//
+#if (defined(DEBUG) && !defined(TARGET_LPC11U24))
+#define INFO(x, ...) std::printf("[INF %s %3d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
+#define WARN(x, ...) std::printf("[WRN %s %3d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
+#define ERR(x, ...) std::printf("[ERR %s %3d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
+#else
+#define INFO(x, ...)
+#define WARN(x, ...)
+#define ERR(x, ...)
+#endif
+
+
+#define RA8875_DISPLAY_WIDTH 480
+#define RA8875_DISPLAY_HEIGHT 272
+
+/// @TODO what is the size?
+/// If we're using the built-in font, read it from the chip.
+/// If we're using a custom font, get it from the font metrics.
+const int size_x = 16;
+const int size_y = 16;
+
+
+#ifdef PERF_METRICS
+#define PERFORMANCE_RESET performance.reset()
+#define REGISTERPERFORMANCE(a) RegisterPerformance(a)
+static const char *metricsName[] =
+{
+ "Point", "Line", "Rectangle", "Rounded Rectangle", "Triangle", "Circle", "Ellipse"
+};
+#else
+#define PERFORMANCE_RESET
+#define REGISTERPERFORMANCE(a)
+#endif
+
+// When it is going to poll a register for completion, how many
+// uSec should it wait between each polling activity.
+#define POLLWAITuSec 10
+
+
+RA8875::RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset, const char *name)
+ : spi(mosi, miso, sclk)
+ , cs(csel)
+ , res(reset)
+ , GraphicsDisplay(name)
+{
+ font = NULL; // no external font, use internal.
+ select(false); // deselect the display
+ frequency(RA8875_DEFAULT_SPI_FREQ); // data rate
+ init();
+#ifdef PERF_METRICS
+ performance.start();
+ ClearPerformance();
+#endif
+}
+
+//RA8875::~RA8875()
+//{
+//}
+
+#ifdef PERF_METRICS
+void RA8875::ClearPerformance()
+{
+ for (int i=0; i<METRICCOUNT; i++)
+ metrics[i] = 0;
+}
+
+void RA8875::RegisterPerformance(method_e method)
+{
+ unsigned long elapsed = performance.read_us();
+
+ if (method < METRICCOUNT && elapsed > metrics[method])
+ metrics[method] = elapsed;
+}
+
+void RA8875::ReportPerformance()
+{
+ for (int i=0; i<METRICCOUNT; i++) {
+ printf("%10d uS %s\r\n", metrics[i], metricsName[i]);
+ }
+}
+#endif
+
+RetCode_t RA8875::WriteCommand(unsigned char command, unsigned int data)
+{
+ select(true);
+ spiwrite(0x80);
+ spiwrite(command);
+ if (data <= 0xFF) { // only if in the valid range
+ spiwrite(0x00);
+ spiwrite(data);
+ }
+ select(false);
+ return noerror;
+}
+
+RetCode_t RA8875::WriteData(unsigned char data)
+{
+ select(true);
+ spiwrite(0x00);
+ spiwrite(data);
+ select(false);
+ return noerror;
+}
+
+unsigned char RA8875::ReadCommand(unsigned char command)
+{
+ WriteCommand(command);
+ return ReadData();
+}
+
+unsigned char RA8875::ReadData(void)
+{
+ unsigned char data;
+
+ select(true);
+ spiwrite(0x40);
+ data = spiread();
+ select(false);
+ return data;
+}
+
+unsigned char RA8875::ReadStatus(void)
+{
+ unsigned char data;
+
+ select(true);
+ spiwrite(0xC0);
+ data = spiread();
+ select(false);
+ return data;
+}
+
+unsigned int RA8875::fontwidth(void)
+{
+ if (font == NULL)
+ return size_x;
+ else
+ return width() / font[1];
+}
+
+unsigned int RA8875::fontheight(void)
+{
+ if (font == NULL)
+ return size_y;
+ else
+ return height() / font[2];
+}
+
+RetCode_t RA8875::locate(unsigned int x, unsigned int y)
+{
+ return SetTextCursor(x * fontwidth(), y * fontheight());
+}
+
+int RA8875::columns(void)
+{
+ return width() / fontwidth();
+}
+
+int RA8875::rows(void)
+{
+ return height() / fontheight();
+}
+
+int RA8875::width(void)
+{
+ return RA8875_DISPLAY_WIDTH;
+}
+
+int RA8875::height(void)
+{
+ return RA8875_DISPLAY_HEIGHT;
+}
+
+RetCode_t RA8875::SetTextCursor(unsigned int x, unsigned int y)
+{
+ WriteCommand(0x2A, x & 0xFF);
+ WriteCommand(0x2B, x >> 8);
+ WriteCommand(0x2C, y & 0xFF);
+ WriteCommand(0x2D, y >> 8);
+ INFO("SetTextCursor(%d,%d)", x,y);
+ return noerror;
+}
+
+RetCode_t RA8875::SetTextFont(RA8875::font_t font)
+{
+ if (/*font >= RA8875::ISO8859_1 && */ font <= RA8875::ISO8859_4) {
+ WriteCommand(0x21, (unsigned int)(font));
+ return noerror;
+ } else {
+ return bad_parameter;
+ }
+}
+
+RetCode_t RA8875::SetTextFontControl(fill_t fillit,
+ RA8875::font_angle_t angle,
+ RA8875::HorizontalScale hScale,
+ RA8875::VerticalScale vScale,
+ RA8875::alignment_t alignment)
+{
+ if (hScale >= 1 && hScale <= 4 &&
+ vScale >= 1 && vScale <= 4) {
+ unsigned char x = 0;
+
+ if (alignment == align_full)
+ x |= 0x80;
+ if (fillit == NOFILL)
+ x |= 0x40;
+ if (angle == rotated)
+ x |= 0x10;
+ x |= ((hScale - 1) << 2);
+ x |= ((vScale - 1) << 0);
+ WriteCommand(0x22, x);
+ return noerror;
+ } else {
+ return bad_parameter;
+ }
+}
+
+RetCode_t RA8875::SetTextFontSize(RA8875::HorizontalScale hScale, RA8875::VerticalScale vScale)
+{
+ unsigned char reg = ReadCommand(0x22);
+
+ if (hScale >= 1 && hScale <= 4 && vScale >= 1 && vScale <= 4) {
+ reg &= 0xF0; // keep the high nibble as is.
+ reg |= ((hScale - 1) << 2);
+ reg |= ((vScale - 1) << 0);
+ WriteCommand(0x22, reg);
+ return noerror;
+ } else {
+ return bad_parameter;
+ }
+}
+
+int RA8875::_putc(int c)
+{
+ if (c) {
+ if (c == '\r') {
+ unsigned int x;
+ x = ReadCommand(0x30) | (ReadCommand(0x31) << 8); // Left edge of active window
+ WriteCommand(0x2A, x & 0xFF);
+ WriteCommand(0x2B, x >> 8);
+ } else if (c == '\n') {
+ unsigned int y;
+ y = ReadCommand(0x2C) | (ReadCommand(0x2D) << 8); // current y location
+ y += fontheight();
+ if (y > height()) // @TODO > active window, then scroll?
+ y = 0;
+ WriteCommand(0x2C, y & 0xFF);
+ WriteCommand(0x2D, y >> 8);
+ } else {
+ if (font == NULL) {
+ WriteCommand(0x40,0x80);
+ WriteCommand(0x02);
+ select(true);
+ WriteData(c);
+ while (ReadStatus() & 0x80)
+ wait_us(POLLWAITuSec); // Chk_Busy();
+ select(false);
+ } else {
+ unsigned int x = (ReadCommand(0x2A) | (ReadCommand(0x2B) << 8)) / fontwidth();
+ unsigned int y = (ReadCommand(0x2C) | (ReadCommand(0x2D) << 8)) / fontheight();
+ character(x,y,c);
+ }
+ // @TODO right of active window, then wrap?
+ }
+ }
+ return c;
+}
+
+void RA8875::puts(unsigned int x, unsigned int y, const char * string)
+{
+ SetTextCursor(x,y);
+ puts(string);
+}
+
+void RA8875::puts(const char * string)
+{
+ if (*string != '\0') {
+ INFO("puts(%s)", string);
+ #if 1
+ while (*string) { // @TODO calling individual _putc is slower... anything to do?
+ _putc(*string++);
+ }
+ #else
+ WriteCommand(0x40,0x80); // Put display into text mode
+ WriteCommand(0x02);
+ select(true);
+ while (*string != '\0') {
+ WriteData(*string);
+ ++string;
+ while (ReadStatus() & 0x80)
+ wait_us(POLLWAITuSec); // Chk_Busy();
+ }
+ select(false);
+ #endif
+ }
+}
+
+RetCode_t RA8875::SetMemoryCursor(unsigned int x, unsigned int y)
+
+{
+ WriteCommand(0x46, x & 0xFF);
+ WriteCommand(0x47, x >> 8);
+ WriteCommand(0x48, y & 0xFF);
+ WriteCommand(0x49, y >> 8);
+ return noerror;
+}
+
+RetCode_t RA8875::SetWindow(unsigned int x, unsigned int y, unsigned int width, unsigned int height)
+{
+ WriteCommand(0x30, x & 0xFF); // HSAW0
+ WriteCommand(0x31, x >> 8); // HSAW1
+ WriteCommand(0x32, y & 0xFF); // VSAW0
+ WriteCommand(0x33, y >> 8); // VSAW1
+ WriteCommand(0x34, (x+width-1) & 0xFF); // HEAW0
+ WriteCommand(0x35, (x+width-1) >> 8); // HEAW1
+ WriteCommand(0x36, (y+height-1) & 0xFF); // VEAW0
+ WriteCommand(0x37, (y+height-1) >> 8); // VEAW1
+ return noerror;
+}
+
+RetCode_t RA8875::cls(void)
+{
+ PERFORMANCE_RESET;
+ clsw(FULLWINDOW);
+ REGISTERPERFORMANCE(PRF_CLS);
+ return noerror;
+}
+
+RetCode_t RA8875::clsw(RA8875::Region_t region)
+{
+ PERFORMANCE_RESET;
+ WriteCommand(0x8E, (region == ACTIVEWINDOW) ? 0xC0 : 0x80);
+ while (ReadCommand(0x8E) & 0x80)
+ wait_us(POLLWAITuSec);
+ REGISTERPERFORMANCE(PRF_CLS);
+ return noerror;
+}
+
+RetCode_t RA8875::pixel(unsigned int x, unsigned int y, color_t color)
+{
+ foreground(color);
+ return pixel(x,y);
+}
+
+RetCode_t RA8875::pixel(unsigned int x, unsigned int y)
+{
+ RetCode_t ret;
+
+ PERFORMANCE_RESET;
+ #if 1
+ color_t color = GetForeColor();
+ WriteCommand(0x40,0x00); // Graphics write mode
+ SetMemoryCursor(x, y);
+ WriteCommand(0x02); //start data write
+ WriteData(color & 0xFF);
+ WriteData(color >> 8);
+ ret = noerror;
+ #else
+ // There isn't actually a set pixel function that I found
+ // so we'll emulate it as we can.
+ ret = line(x,y, x,y);
+ #endif
+ REGISTERPERFORMANCE(PRF_DRAWPOINT);
+ return ret;
+}
+
+RetCode_t RA8875::line(unsigned int x1, unsigned int y1, unsigned int x2, unsigned int y2, color_t color)
+{
+ foreground(color);
+ return line(x1,y1,x2,y2);
+}
+
+RetCode_t RA8875::line(unsigned int x1, unsigned int y1, unsigned int x2, unsigned int y2)
+{
+ PERFORMANCE_RESET;
+ WriteCommand(0x91, x1 & 0xFF);
+ WriteCommand(0x92, x1 >> 8);
+ WriteCommand(0x93, y1 & 0xFF);
+ WriteCommand(0x94, y1 >> 8);
+ WriteCommand(0x95, x2 & 0xFF);
+ WriteCommand(0x96, x2 >> 8);
+ WriteCommand(0x97, y2 & 0xFF);
+ WriteCommand(0x98, y2 >> 8);
+
+ unsigned char drawCmd = 0x00; // Line
+ WriteCommand(0x90, drawCmd);
+ WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
+ while (ReadCommand(0x90) & 0x80) // await completion.
+ wait_us(POLLWAITuSec);
+ REGISTERPERFORMANCE(PRF_DRAWLINE);
+ return noerror;
+}
+
+RetCode_t RA8875::fillrect(unsigned int x1, unsigned int y1, unsigned int x2, unsigned int y2,
+ color_t color, fill_t fillit)
+{
+ return rect(x1,y1,x2,y2,color,fillit);
+}
+
+RetCode_t RA8875::rect(unsigned int x1, unsigned int y1, unsigned int x2, unsigned int y2,
+ color_t color, fill_t fillit)
+{
+ foreground(color);
+ return rect(x1,y1,x2,y2,fillit);
+}
+
+RetCode_t RA8875::rect(unsigned int x1, unsigned int y1, unsigned int x2, unsigned int y2,
+ fill_t fillit)
+{
+ PERFORMANCE_RESET;
+ if (x1 == x2 && y1 == y2) {
+ pixel(x1, y1);
+ } else if (x1 == x2) {
+ line(x1, y1, x2, y2);
+ } else if (y1 == y2) {
+ line(x1, y1, x2, y2);
+ } else {
+ WriteCommand(0x91, x1 & 0xFF);
+ WriteCommand(0x92, x1 >> 8);
+ WriteCommand(0x93, y1 & 0xFF);
+ WriteCommand(0x94, y1 >> 8);
+ WriteCommand(0x95, x2 & 0xFF);
+ WriteCommand(0x96, x2 >> 8);
+ WriteCommand(0x97, y2 & 0xFF);
+ WriteCommand(0x98, y2 >> 8);
+
+ unsigned char drawCmd = 0x10; // Rectangle
+ if (fillit == FILL)
+ drawCmd |= 0x20;
+ WriteCommand(0x90, drawCmd);
+ WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
+ while (ReadCommand(0x90) & 0x80) // await completion.
+ wait_us(POLLWAITuSec);
+ }
+ REGISTERPERFORMANCE(PRF_DRAWRECTANGLE);
+ return noerror;
+}
+
+RetCode_t RA8875::fillroundrect(unsigned int x1, unsigned int y1, unsigned int x2, unsigned int y2,
+ unsigned int radius1, unsigned int radius2, color_t color, fill_t fillit)
+{
+ foreground(color);
+ return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
+}
+
+RetCode_t RA8875::roundrect(unsigned int x1, unsigned int y1, unsigned int x2, unsigned int y2,
+ unsigned int radius1, unsigned int radius2, color_t color, fill_t fillit)
+{
+ foreground(color);
+ return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
+}
+
+RetCode_t RA8875::roundrect(unsigned int x1, unsigned int y1 ,unsigned int x2, unsigned int y2,
+ unsigned int radius1, unsigned int radius2, fill_t fillit)
+{
+ RetCode_t ret = noerror;
+
+ PERFORMANCE_RESET;
+ if (x1 == x2 && y1 == y2) {
+ pixel(x1, y1);
+ } else if (x1 == x2) {
+ line(x1, y1, x2, y2);
+ } else if (y1 == y2) {
+ line(x1, y1, x2, y2);
+ } else {
+ WriteCommand(0x91, x1 & 0xFF);
+ WriteCommand(0x92, x1 >> 8);
+ WriteCommand(0x93, y1 & 0xFF);
+ WriteCommand(0x94, y1 >> 8);
+ WriteCommand(0x95, x2 & 0xFF);
+ WriteCommand(0x96, x2 >> 8);
+ WriteCommand(0x97, y2 & 0xFF);
+ WriteCommand(0x98, y2 >> 8);
+
+ //while (r && r > (x2 - x1) || r > (y2 - y1))
+ // r--;
+ WriteCommand(0xA1, radius1 & 0xFF);
+ WriteCommand(0xA2, radius1 >> 8);
+ WriteCommand(0xA3, radius2 & 0xFF);
+ WriteCommand(0xA4, radius2 >> 8);
+
+ unsigned char drawCmd = 0x20; // Rounded Rectangle
+ if (fillit == FILL)
+ drawCmd |= 0x40;
+ WriteCommand(0xA0, drawCmd);
+ WriteCommand(0xA0, 0x80 + drawCmd); // Start drawing.
+ while (ReadCommand(0xA0) & 0x80) { // await completion.
+ wait_us(POLLWAITuSec);
+ }
+ }
+ REGISTERPERFORMANCE(PRF_DRAWROUNDEDRECTANGLE);
+ return ret;
+}
+
+RetCode_t RA8875::triangle(unsigned int x1, unsigned int y1, unsigned int x2, unsigned int y2,
+ unsigned int x3, unsigned int y3, color_t color, fill_t fillit)
+{
+ foreground(color);
+ return triangle(x1,y1,x2,y2,x3,y3,color,fillit);
+}
+
+RetCode_t RA8875::filltriangle(unsigned int x1, unsigned int y1, unsigned int x2, unsigned int y2,
+ unsigned int x3, unsigned int y3, color_t color, fill_t fillit)
+{
+ foreground(color);
+ return triangle(x1,y1,x2,y2,x3,y3,color,fillit);
+}
+
+RetCode_t RA8875::triangle(unsigned int x1, unsigned int y1 ,unsigned int x2, unsigned int y2,
+ unsigned int x3, unsigned int y3, fill_t fillit)
+{
+ RetCode_t ret = noerror;
+
+ PERFORMANCE_RESET;
+ if (x1 == x2 && y1 == y2 && x1 == x3 && y1 == y3) {
+ pixel(x1, y1);
+ } else {
+ WriteCommand(0x91, x1 & 0xFF);
+ WriteCommand(0x92, x1 >> 8);
+ WriteCommand(0x93, y1 & 0xFF);
+ WriteCommand(0x94, y1 >> 8);
+
+ WriteCommand(0x95, x2 & 0xFF);
+ WriteCommand(0x96, x2 >> 8);
+ WriteCommand(0x97, y2 & 0xFF);
+ WriteCommand(0x98, y2 >> 8);
+
+ WriteCommand(0xA9, x3 & 0xFF);
+ WriteCommand(0xAA, x3 >> 8);
+ WriteCommand(0xAB, y3 & 0xFF);
+ WriteCommand(0xAC, y3 >> 8);
+
+ unsigned char drawCmd = 0x01; // Triangle
+ if (fillit == FILL)
+ drawCmd |= 0x20;
+ WriteCommand(0x90, drawCmd);
+ WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
+ while (ReadCommand(0x90) & 0x80) // await completion.
+ wait_us(POLLWAITuSec);
+ }
+ REGISTERPERFORMANCE(PRF_DRAWTRIANGLE);
+ return ret;
+}
+
+RetCode_t RA8875::circle(unsigned int x, unsigned int y, unsigned int radius,
+ color_t color, fill_t fillit)
+{
+ foreground(color);
+ return circle(x,y,radius,fillit);
+}
+
+RetCode_t RA8875::fillcircle(unsigned int x, unsigned int y, unsigned int radius,
+ color_t color, fill_t fillit)
+{
+ foreground(color);
+ return circle(x,y,radius,fillit);
+}
+
+RetCode_t RA8875::circle(unsigned int x, unsigned int y, unsigned int radius, fill_t fillit)
+{
+ RetCode_t ret = noerror;
+
+ PERFORMANCE_RESET;
+ if (radius <= 0) {
+ ret = bad_parameter;
+ } else if (radius == 1) {
+ pixel(x,y);
+ } else {
+ WriteCommand(0x99, x & 0xFF);
+ WriteCommand(0x9a, x >> 8);
+ WriteCommand(0x9b, y & 0xFF);
+ WriteCommand(0x9c, y >> 8);
+ WriteCommand(0x9d, radius & 0xFF);
+
+ unsigned char drawCmd = 0x00; // Circle
+ if (fillit == FILL)
+ drawCmd |= 0x20;
+ WriteCommand(0x90, drawCmd);
+ WriteCommand(0x90, 0x40 + drawCmd); // Start drawing.
+ while (ReadCommand(0x90) & 0x40) // await completion.
+ wait_us(POLLWAITuSec);
+ }
+ REGISTERPERFORMANCE(PRF_DRAWCIRCLE);
+ return ret;
+}
+
+RetCode_t RA8875::ellipse(unsigned int x, unsigned int y, unsigned int R1, unsigned int R2, color_t color, fill_t fillit)
+{
+ foreground(color);
+ return ellipse(x,y,R1,R2,fillit);
+}
+
+RetCode_t RA8875::ellipse(unsigned int x, unsigned int y, unsigned int R1, unsigned int R2, fill_t fillit)
+{
+ RetCode_t ret = noerror;
+
+ PERFORMANCE_RESET;
+ if (R1 <= 0 || R2 <= 0) {
+ ; // do nothing
+ } else if (R1 == 1 && R2 == 1) {
+ pixel(x, y);
+ } else {
+ WriteCommand(0xA5, x & 0xFF);
+ WriteCommand(0xA6, x >> 8);
+ WriteCommand(0xA7, y & 0xFF);
+ WriteCommand(0xA8, y >> 8);
+ WriteCommand(0xA1, R1 & 0xFF);
+ WriteCommand(0xA2, R1 >> 8);
+ WriteCommand(0xA3, R2 & 0xFF);
+ WriteCommand(0xA4, R2 >> 8);
+
+ unsigned char drawCmd = 0x00; // Ellipse
+ if (fillit == FILL)
+ drawCmd |= 0x40;
+ WriteCommand(0xA0, drawCmd);
+ WriteCommand(0xA0, 0x80 + drawCmd); // Start drawing.
+ while (ReadCommand(0xA0) & 0x80) // await completion.
+ wait_us(POLLWAITuSec);
+ }
+ REGISTERPERFORMANCE(PRF_DRAWELLIPSE);
+ return ret;
+}
+
+
+RetCode_t RA8875::frequency(unsigned long Hz)
+{
+ spi.frequency(Hz);
+ // __ ___
+ // Clock ___A Rising edge latched
+ // ___ ____
+ // Data ___X____
+ spi.format(8, 3); // 8 bits and clock to data phase 0
+ init();
+ return noerror;
+}
+
+RetCode_t RA8875::Power(bool on)
+{
+ WriteCommand(0x01, (on) ? 0x80 : 0x00);
+ return noerror;
+}
+
+RetCode_t RA8875::Reset(void)
+{
+ WriteCommand(0x01, 0x01); // Apply Display Off, Reset
+ wait_ms(2); // no idea if I need to wait, or how long
+ WriteCommand(0x01, 0x00); // Display off, Remove reset
+ wait_ms(2); // no idea if I need to wait, or how long
+ init();
+ return noerror;
+}
+
+
+RetCode_t RA8875::Backlight_u8(unsigned char brightness)
+{
+ static bool is_enabled = false;
+ if (brightness == 0) {
+ WriteCommand(0x8a); // Disable the PWM
+ WriteData(0x00);
+ is_enabled = false;
+ } else if (!is_enabled) {
+ WriteCommand(0x8a); // Enable the PWM
+ WriteData(0x80);
+ WriteCommand(0x8a); // Not sure why this is needed, but following the pattern
+ WriteData(0x81); // open PWM (SYS_CLK / 2 as best I can tell)
+ is_enabled = true;
+ }
+ WriteCommand(0x8b, brightness); // Brightness parameter 0xff-0x00
+ return noerror;
+}
+
+RetCode_t RA8875::Backlight(float brightness)
+{
+ unsigned char b;
+
+ if (brightness > 1.0)
+ b = 255;
+ else if (brightness < 0)
+ b = 0;
+ else
+ b = (unsigned char)(brightness * 255);
+ return Backlight_u8(b);
+}
+
+
+RetCode_t RA8875::set_font(const unsigned char * _font)
+{
+ font = _font;
+ return noerror; // trusting them, but we could put some checks in here...
+}
+
+RetCode_t RA8875::background(color_t color)
+{
+ WriteCommand(0x60, (color>>11)); // BGCR0
+ WriteCommand(0x61, (unsigned char)(color>>5)); // BGCR0
+ WriteCommand(0x62, (unsigned char)(color)); // BGCR0
+ return noerror;
+}
+
+RetCode_t RA8875::background(unsigned char r, unsigned char g, unsigned char b)
+{
+ WriteCommand(0x60, r);
+ WriteCommand(0x61, g);
+ WriteCommand(0x62, b);
+ return noerror;
+}
+
+RetCode_t RA8875::foreground(color_t color)
+{
+ WriteCommand(0x63, (unsigned char)(color>>11));
+ WriteCommand(0x64, (unsigned char)(color>>5));
+ WriteCommand(0x65, (unsigned char)(color));
+ return noerror;
+}
+
+RetCode_t RA8875::foreground(unsigned char setR, unsigned char setG, unsigned char setB)
+{
+ WriteCommand(0x63, setR);
+ WriteCommand(0x64, setG);
+ WriteCommand(0x65, setB);
+ return noerror;
+}
+
+unsigned int RA8875::GetForeColor(void)
+{
+ color_t color;
+
+ color = (ReadCommand(0x63) & 0x1F) << 11;
+ color |= (ReadCommand(0x64) & 0x3F) << 5;
+ color |= (ReadCommand(0x65) & 0x1F);
+ return color;
+}
+
+color_t RA8875::DOSColor(int i)
+ {
+ const color_t colors[16] =
+ {
+ Black, Blue, Green, Cyan,
+ Red, Magenta, Brown, Gray,
+ Charcoal, BrightBlue, BrightGreen, BrightCyan,
+ Orange, Pink, Yellow, White
+ };
+ if (i < 16)
+ return colors[i];
+ else
+ return 0;
+ }
+
+const char * RA8875::DOSColorNames(int i)
+ {
+ const char * names[16] =
+ {
+ "Black", "Blue", "Green", "Cyan",
+ "Red", "Magenta", "Brown", "Gray",
+ "Charcoal", "BrightBlue", "BrightGreen", "BrightCyan",
+ "Orange", "Pink", "Yellow", "White"
+ };
+ if (i < 16)
+ return names[i];
+ else
+ return NULL;
+ }
+
+
+///////////////////////////////////////////////////////////////
+// Private functions
+
+unsigned char RA8875::spiwrite(unsigned char data)
+{
+ unsigned char retval;
+
+ retval = spi.write(data);
+ return retval;
+}
+
+unsigned char RA8875::spiread(void)
+{
+ unsigned char retval;
+ unsigned char data = 0;
+
+ retval = spi.write(data);
+ return retval;
+}
+
+RetCode_t RA8875::select(bool chipsel)
+{
+ cs = (chipsel == true) ? 0 : 1;
+ return noerror;
+}
+
+RetCode_t RA8875::init(void)
+{
+ Backlight_u8(0);
+ WriteCommand(0x88, 0x0a); // PLLC1 - Phase Lock Loop registers
+ wait_ms(1);
+ WriteCommand(0x89, 0x02);
+ wait_ms(1);
+
+ //?
+ WriteCommand(0x10, 0x0C); //SYSR bit[4:3]=00 256 color bit[2:1]= 00 8bit MPU interface, 1x 64k color 1x 16bit
+
+ //?
+ WriteCommand(0x04, 0x82); //PCLK
+ wait_ms(1);
+
+ // Horizontal Settings
+ WriteCommand(0x14, RA8875_DISPLAY_WIDTH/8 - 1); //HDWR//Horizontal Display Width Setting Bit[6:0]
+ WriteCommand(0x15, 0x02); //HNDFCR//Horizontal Non-Display Period fine tune Bit[3:0]
+ WriteCommand(0x16, 0x03); //HNDR//Horizontal Non-Display Period Bit[4:0]
+ WriteCommand(0x17, 0x01); //HSTR//HSYNC Start Position[4:0]
+ WriteCommand(0x18, 0x03); //HPWR//HSYNC Polarity ,The period width of HSYNC.
+
+ // Vertical Settings
+ WriteCommand(0x19, (RA8875_DISPLAY_HEIGHT-1)&0xFF); //VDHR0 //Vertical Display Height Bit [7:0]
+ WriteCommand(0x1a, (RA8875_DISPLAY_HEIGHT-1)>>8); //VDHR1 //Vertical Display Height Bit [8]
+ WriteCommand(0x1b, 0x0F); //VNDR0 //Vertical Non-Display Period Bit [7:0]
+ WriteCommand(0x1c, 0x00); //VNDR1 //Vertical Non-Display Period Bit [8]
+ WriteCommand(0x1d, 0x0e); //VSTR0 //VSYNC Start Position[7:0]
+ WriteCommand(0x1e, 0x06); //VSTR1 //VSYNC Start Position[8]
+ WriteCommand(0x1f, 0x01); //VPWR //VSYNC Polarity ,VSYNC Pulse Width[6:0]
+
+ // Clear ram image
+ SetWindow(0,0, width(), height()); // Initialize to full screen
+ foreground(Black);
+ background(Black);
+ cls();
+ return noerror;
+}
+