Marcel Visser
brw1
Diff: RA8875/RA8875.cpp
- Revision:
- 0:a115ff47d1c1
diff -r 000000000000 -r a115ff47d1c1 RA8875/RA8875.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/RA8875/RA8875.cpp Mon Nov 30 11:13:18 2015 +0000
@@ -0,0 +1,2462 @@
+/// RA8875 Display Controller Library.
+///
+/// This is being created for a Raio RA8875-based display from buydisplay.com,
+/// which is 480 x 272 using a 4-wire SPI interface. Support is provided for
+/// both a keypad and a resistive touch-screen.
+///
+/// This display controller is used in other display resolutions, up to 800x600.
+/// While this driver has not been tested with these variants, nothing was done
+/// to prevent easily supporting them.
+///
+#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__);
+static void HexDump(char * title, uint8_t * p, int count)
+{
+ int i;
+ char buf[100] = "0000: ";
+
+ if (*title)
+ INFO("%s", title);
+ for (i=0; i<count; ) {
+ sprintf(buf + strlen(buf), "%02X ", *(p+i));
+ if ((++i & 0x0F) == 0x00) {
+ INFO("%s", buf);
+ if (i < count)
+ sprintf(buf, "%04X: ", i);
+ else
+ buf[0] = '\0';
+ }
+ }
+ if (strlen(buf))
+ INFO("%s", buf);
+}
+#else
+#define INFO(x, ...)
+#define WARN(x, ...)
+#define ERR(x, ...)
+#define HexDump(a, b, c)
+#endif
+
+
+#define RA8875_DISPLAY_WIDTH 480
+#define RA8875_DISPLAY_HEIGHT 272
+#define RA8875_COLORDEPTH_BPP 16 /* Not an API */
+
+#ifdef PERF_METRICS
+#define PERFORMANCE_RESET performance.reset()
+#define REGISTERPERFORMANCE(a) RegisterPerformance(a)
+#define COUNTIDLETIME(a) CountIdleTime(a)
+static const char *metricsName[] = {
+ "Cls", "Pixel", "Pixel Stream",
+ "Read Pixel", "Read Pixel Stream",
+ "Line",
+ "Rectangle", "Rounded Rectangle",
+ "Triangle", "Circle", "Ellipse"
+};
+#else
+#define PERFORMANCE_RESET
+#define REGISTERPERFORMANCE(a)
+#define COUNTIDLETIME(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
+
+// Private RawKeyMap for the Keyboard interface
+static const uint8_t DefaultKeyMap[22] = {
+ 0,
+ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+ 255
+};
+
+static const char * ErrMessages[] = {
+ "noerror", ///< no errors, command completed successfully
+ "bad_parameter", ///< one or more parameters are invalid
+ "file_not_found", ///< specified file could not be found
+ "not_bmp_format", ///< file is not a .bmp file
+ "not_ico_format", ///< file is not a .ico file
+ "not_supported_format", ///< file format is not yet supported
+ "image_too_big", ///< image is too large for the screen
+ "not_enough_ram", ///< could not allocate ram for scanline
+};
+
+RA8875::RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset, const char *name)
+ : GraphicsDisplay(name)
+ , spi(mosi, miso, sclk)
+ , cs(csel)
+ , res(reset)
+{
+}
+
+//RA8875::~RA8875()
+//{
+//}
+
+RetCode_t RA8875::init(int width, int height, int color_bpp, bool poweron, bool keypadon, bool touchscreenon)
+{
+ font = NULL; // no external font, use internal.
+ pKeyMap = DefaultKeyMap; // set default key map
+ _select(false); // deselect the display
+ frequency(RA8875_DEFAULT_SPI_FREQ); // data rate
+ Reset();
+ WriteCommand(0x88, 0x0B); // PLLC1 - Phase Lock Loop registers
+ wait_ms(1);
+ WriteCommand(0x89, 0x02);
+ wait_ms(1);
+
+ // System Config Register (SYSR)
+ if (color_bpp == 16) {
+ WriteCommand(0x10, 0x0C); // 16-bpp (65K colors) color depth, 8-bit interface
+ } else { // color_bpp == 8
+ WriteCommand(0x10, 0x00); // 8-bpp (256 colors)
+ }
+ // Pixel Clock Setting Register (PCSR)
+ WriteCommand(0x04, 0x82); // PDAT on PCLK falling edge, PCLK = 4 x System Clock
+ wait_ms(1);
+
+ // Horizontal Settings
+ WriteCommand(0x14, 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, (height-1)&0xFF); //VDHR0 //Vertical Display Height Bit [7:0]
+ WriteCommand(0x1a, (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]
+
+ if (width >= 800 && height >= 480 && color_bpp > 8) {
+ WriteCommand(0x20, 0x00); // DPCR - 1-layer mode when the resolution is too high
+ } else {
+ WriteCommand(0x20, 0x80); // DPCR - 2-layer mode
+ }
+
+ // Set display image to Blue on Black as default
+ window(0,0, width, height); // Initialize to full screen
+ SetTextCursorControl();
+ foreground(Blue);
+ background(Black);
+ cls(3);
+
+ Power(poweron);
+ if (poweron)
+ Backlight_u8(255);
+ if (keypadon)
+ KeypadInit();
+ if (touchscreenon)
+ TouchPanelInit();
+#ifdef PERF_METRICS
+ performance.start();
+ ClearPerformance();
+#endif
+ return noerror;
+}
+
+
+RetCode_t RA8875::Reset(void)
+{
+ RetCode_t ret;
+
+ ret = WriteCommand(0x01, 0x01); // Apply Display Off, Reset
+ wait_ms(2); // no idea if I need to wait, or how long
+ if (ret == noerror) {
+ ret = WriteCommand(0x01, 0x00); // Display off, Remove reset
+ wait_ms(2); // no idea if I need to wait, or how long
+ }
+ return ret;
+}
+
+
+const char * RA8875::GetErrorMessage(RetCode_t code)
+{
+ if (code >= LastErrCode)
+ code = bad_parameter;
+ return ErrMessages[code];
+}
+
+
+uint16_t RA8875::GetDrawingLayer(void)
+{
+ return (ReadCommand(0x41) & 0x01);
+}
+
+
+RetCode_t RA8875::SelectDrawingLayer(uint16_t layer)
+{
+ unsigned char mwcr1 = ReadCommand(0x41) & ~0x01; // retain all but the currently selected layer
+
+ if (width() >= 800 && height() >= 480 && color_bpp() == 8) {
+ return bad_parameter;
+ } else if (layer > 1) {
+ return bad_parameter;
+ } else { // layer == 0 ro 1
+ return WriteCommand(0x41, mwcr1 | layer);
+ }
+}
+
+
+RetCode_t RA8875::SetLayerMode(LayerMode_T mode)
+{
+ unsigned char ltpr0 = ReadCommand(0x52) & ~0x7; // retain all but the display layer mode
+ if (mode <= (LayerMode_T)6) {
+ WriteCommand(0x52, ltpr0 | (mode & 0x7));
+ return noerror;
+ } else {
+ return bad_parameter;
+ }
+}
+
+
+RetCode_t RA8875::SetLayerTransparency(uint8_t layer1, uint8_t layer2)
+{
+ if (layer1 > 8)
+ layer1 = 8;
+ if (layer2 > 8)
+ layer2 = 8;
+ WriteCommand(0x53, ((layer2 & 0xF) << 4) | (layer1 & 0xF));
+ return noerror;
+}
+
+
+RetCode_t RA8875::SetBackgroundTransparencyColor(color_t color)
+{
+ WriteCommand(0x67, (color >> 11) & 0x1F);
+ WriteCommand(0x68, (color >> 5) & 0x3F);
+ WriteCommand(0x69, (color & 0x1F));
+ return noerror;
+}
+
+
+color_t RA8875::GetBackgroundTransparencyColor(void)
+{
+ RGBQUAD q;
+ q.rgbRed = ReadCommand(0x67);
+ q.rgbGreen = ReadCommand(0x68);
+ q.rgbBlue = ReadCommand(0x69);
+ return RGBQuadToRGB16(&q, 0);
+}
+
+
+RetCode_t RA8875::KeypadInit(bool scanEnable, bool longDetect, uint8_t sampleTime, uint8_t scanFrequency,
+ uint8_t longTimeAdjustment, bool interruptEnable, bool wakeupEnable)
+{
+ uint8_t value = 0;
+
+ if (sampleTime > 3 || scanFrequency > 7 || longTimeAdjustment > 3)
+ return bad_parameter;
+ value |= (scanEnable) ? 0x80 : 0x00;
+ value |= (longDetect) ? 0x40 : 0x00;
+ value |= (sampleTime & 0x03) << 4;
+ value |= (scanFrequency & 0x07);
+ WriteCommand(0xC0, value); // KSCR1 - Enable Key Scan (and ignore possibility of an error)
+
+ value = 0;
+ value |= (wakeupEnable) ? 0x80 : 0x00;
+ value |= (longTimeAdjustment & 0x03) << 2;
+ WriteCommand(0xC1, value); // KSCR2 - (and ignore possibility of an error)
+
+ value = ReadCommand(0xF0); // (and ignore possibility of an error)
+ value &= ~0x10;
+ value |= (interruptEnable) ? 0x10 : 0x00;
+ return WriteCommand(0xF0, value); // INT
+}
+
+
+RetCode_t RA8875::SetKeyMap(const uint8_t * CodeList)
+{
+ pKeyMap = CodeList;
+ return noerror;
+}
+
+
+bool RA8875::readable(void)
+{
+ return (ReadCommand(0xF1) & 0x10); // check KS status - true if kbhit
+}
+
+
+uint8_t RA8875::getc(void)
+{
+ //#define GETC_DEV // for development
+#ifdef GETC_DEV
+ uint8_t keyCode1, keyCode2;
+#endif
+ uint8_t keyCode3;
+ static uint8_t count = 0;
+ uint8_t col, row;
+ uint8_t key;
+
+ while (!readable()) {
+ wait_us(POLLWAITuSec);
+ // COUNTIDLETIME(POLLWAITuSec); // As it is voluntary to call the getc and pend. Don't tally it.
+ }
+ // read the key press number
+ uint8_t keyNumReg = ReadCommand(0xC1) & 0x03;
+ count++;
+ switch (keyNumReg) {
+ case 0x01: // one key
+ keyCode3 = ReadCommand(0xC2);
+#ifdef GETC_DEV
+ keyCode2 = 0;
+ keyCode1 = 0;
+#endif
+ break;
+ case 0x02: // two keys
+ keyCode3 = ReadCommand(0xC3);
+#ifdef GETC_DEV
+ keyCode2 = ReadCommand(0xC2);
+ keyCode1 = 0;
+#endif
+ break;
+ case 0x03: // three keys
+ keyCode3 = ReadCommand(0xC4);
+#ifdef GETC_DEV
+ keyCode2 = ReadCommand(0xC3);
+ keyCode1 = ReadCommand(0xC2);
+#endif
+ break;
+ default: // no keys (key released)
+ keyCode3 = 0xFF;
+#ifdef GETC_DEV
+ keyCode2 = 0;
+ keyCode1 = 0;
+#endif
+ break;
+ }
+ if (keyCode3 == 0xFF)
+ key = pKeyMap[0]; // Key value 0
+ else {
+ row = (keyCode3 >> 4) & 0x03;
+ col = (keyCode3 & 7);
+ key = row * 5 + col + 1; // Keys value 1 - 20
+ if (key > 21) {
+ key = 21;
+ }
+ key = pKeyMap[key];
+ key |= (keyCode3 & 0x80); // combine the key held flag
+ }
+#if GETC_DEV // for Development only
+ SetTextCursor(0, 20);
+ printf(" Reg: %02x\r\n", keyNumReg);
+ printf(" key1: %02x\r\n", keyCode1);
+ printf(" key2: %02x\r\n", keyCode2);
+ printf(" key3: %02x\r\n", keyCode3);
+ printf(" count: %02X\r\n", count);
+ printf(" key: %02X\r\n", key);
+#endif
+ WriteCommand(0xF1, 0x10); // Clear KS status
+ return key;
+}
+
+
+#ifdef PERF_METRICS
+void RA8875::ClearPerformance()
+{
+ for (int i=0; i<METRICCOUNT; i++)
+ metrics[i] = 0;
+ idletime_usec = 0;
+}
+
+
+void RA8875::RegisterPerformance(method_e method)
+{
+ unsigned long elapsed = performance.read_us();
+
+ if (method < METRICCOUNT && elapsed > metrics[method])
+ metrics[method] = elapsed;
+}
+
+
+void RA8875::CountIdleTime(uint32_t t)
+{
+ idletime_usec += t;
+}
+
+
+void RA8875::ReportPerformance(Serial & pc)
+{
+ pc.printf("\r\nPerformance Metrics\r\n");
+ for (int i=0; i<METRICCOUNT; i++) {
+ pc.printf("%10d uS %s\r\n", metrics[i], metricsName[i]);
+ }
+ pc.printf("%10d uS Idle time polling display for ready.\r\n", idletime_usec);
+}
+#endif
+
+
+RetCode_t RA8875::WriteCommandW(uint8_t command, uint16_t data)
+{
+#if 1
+ WriteCommand(command, data & 0xFF);
+ WriteCommand(command+1, data >> 8);
+#else
+ // This should be a little faster, but doesn't work...
+ INFO("WriteCommandW(%02X, %04X)", command, data);
+ _select(true);
+ _spiwrite(0x80);
+ _spiwrite(command);
+ //_spiwrite(0x00); // dummy
+ _spiwrite(data & 0xFF);
+ _spiwrite(data >> 8);
+ _select(false);
+#endif
+ return noerror;
+}
+
+
+RetCode_t RA8875::WriteCommand(unsigned char command, unsigned int data)
+{
+ _select(true);
+ _spiwrite(0x80); // cmd: write command
+ _spiwrite(command);
+ if (data <= 0xFF) { // only if in the valid range
+ _spiwrite(0x00);
+ _spiwrite(data);
+ }
+ _select(false);
+ return noerror;
+}
+
+
+RetCode_t RA8875::WriteDataW(uint16_t data)
+{
+ _select(true);
+ _spiwrite(0x00); // cmd: write data
+ _spiwrite(data & 0xFF);
+ _spiwrite(data >> 8);
+ _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;
+}
+
+
+uint16_t RA8875::ReadDataW(void)
+{
+ uint16_t data;
+
+ _select(true);
+ _spiwrite(0x40);
+ data = _spiread();
+ data |= (_spiread() << 8);
+ _select(false);
+ return data;
+}
+
+
+unsigned char RA8875::ReadStatus(void)
+{
+ unsigned char data;
+
+ _select(true);
+ _spiwrite(0xC0); // These two bits are for the special "Status Read" [STSR]
+ data = _spiread();
+ _select(false);
+ return data;
+}
+
+
+/// @todo add a timeout and return false, but how long
+/// to wait since some operations can be very long.
+bool RA8875::_WaitWhileBusy(uint8_t mask)
+{
+ int i = 20000/POLLWAITuSec; // 20 msec max
+
+ while (i-- && ReadStatus() & mask) {
+ wait_us(POLLWAITuSec);
+ COUNTIDLETIME(POLLWAITuSec);
+ }
+ if (i)
+ return true;
+ else
+ return false;
+}
+
+
+/// @todo add a timeout and return false, but how long
+/// to wait since some operations can be very long.
+bool RA8875::_WaitWhileReg(uint8_t reg, uint8_t mask)
+{
+ int i = 20000/POLLWAITuSec; // 20 msec max
+
+ while (i-- && ReadCommand(reg) & mask) {
+ wait_us(POLLWAITuSec);
+ COUNTIDLETIME(POLLWAITuSec);
+ }
+ if (i)
+ return true;
+ else
+ return false;
+}
+
+
+dim_t RA8875::fontwidth(void)
+{
+ if (font == NULL)
+ return (((ReadCommand(0x22) >> 2) & 0x3) + 1) * 8;
+ else
+ return font[1];
+}
+
+
+dim_t RA8875::fontheight(void)
+{
+ if (font == NULL)
+ return (((ReadCommand(0x22) >> 0) & 0x3) + 1) * 16;
+ else
+ return font[2];
+}
+
+
+RetCode_t RA8875::locate(textloc_t column, textloc_t row)
+{
+ return SetTextCursor(column * fontwidth(), row * fontheight());
+}
+
+
+int RA8875::columns(void)
+{
+ return width() / fontwidth();
+}
+
+
+int RA8875::rows(void)
+{
+ return height() / fontheight();
+}
+
+
+dim_t RA8875::width(void)
+{
+ return (ReadCommand(0x14) + 1) * 8;
+}
+
+
+dim_t RA8875::height(void)
+{
+ return (ReadCommand(0x19) | (ReadCommand(0x1A) << 8)) + 1;
+}
+
+
+dim_t RA8875::color_bpp(void)
+{
+ if ((ReadCommand(0x10) & 0x0C) == 0x04)
+ return 16;
+ else
+ return 8;
+}
+
+
+RetCode_t RA8875::SetTextCursor(loc_t x, loc_t y)
+{
+ cursor_x = x; // set these values for non-internal fonts
+ cursor_y = y;
+ WriteCommandW(0x2A, x);
+ WriteCommandW(0x2C, y);
+ return noerror;
+}
+
+
+loc_t RA8875::GetTextCursor_Y(void)
+{
+ if (font == NULL)
+ return ReadCommand(0x2C) | (ReadCommand(0x2D) << 8);
+ else
+ return cursor_y;
+}
+
+
+loc_t RA8875::GetTextCursor_X(void)
+{
+ if (font == NULL)
+ return ReadCommand(0x2A) | (ReadCommand(0x2B) << 8);
+ else
+ return cursor_x;
+}
+
+
+RetCode_t RA8875::SetTextCursorControl(cursor_t cursor, bool blink)
+{
+ unsigned char mwcr0 = ReadCommand(0x40) & 0x0F; // retain direction, auto-increase
+ unsigned char mwcr1 = ReadCommand(0x41) & 0x01; // retain currently selected layer
+ unsigned char horz = 0;
+ unsigned char vert = 0;
+
+ mwcr0 |= 0x80; // text mode
+ if (cursor != NOCURSOR)
+ mwcr0 |= 0x40; // visible
+ if (blink)
+ mwcr0 |= 0x20; // blink
+ WriteCommand(0x40, mwcr0); // configure the cursor
+ WriteCommand(0x41, mwcr1); // close the graphics cursor
+ WriteCommand(0x44, 0x1f); // The cursor flashing cycle
+ switch (cursor) {
+ case IBEAM:
+ horz = 0x01;
+ vert = 0x1F;
+ break;
+ case UNDER:
+ horz = 0x07;
+ vert = 0x01;
+ break;
+ case BLOCK:
+ horz = 0x07;
+ vert = 0x1F;
+ break;
+ case NOCURSOR:
+ default:
+ break;
+ }
+ WriteCommand(0x4e, horz); // The cursor size horz
+ WriteCommand(0x4f, vert); // The cursor size vert
+ 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 (vScale == -1)
+ vScale = hScale;
+ 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 (font == NULL) {
+ return _internal_putc(c);
+ } else {
+ return _external_putc(c);
+ }
+}
+
+
+int RA8875::_external_putc(int c)
+{
+ if (c) {
+ if (c == '\r') {
+ cursor_x = 0;
+ } else if (c == '\n') {
+ cursor_y += font[2];
+ } else {
+ int advance = character(cursor_x, cursor_y, c); // advance tells us how many pixels we advanced
+ //INFO("x,y,advance %d,%d,%d", cursor_x, cursor_y, advance);
+ if (advance) {
+ cursor_x += advance;
+ if (cursor_x >= width()) {
+ cursor_x = 0;
+ cursor_y += font[2];
+ if (cursor_y >= height()) {
+ cursor_y = 0; // @todo Should it scroll?
+ }
+ }
+ }
+ }
+ }
+ return c;
+}
+
+
+int RA8875::_internal_putc(int c)
+{
+ if (c) {
+ unsigned char mwcr0;
+
+ mwcr0 = ReadCommand(0x40);
+ if ((mwcr0 & 0x80) == 0x00) {
+ WriteCommand(0x40, 0x80 | mwcr0); // Put in Text mode if not already
+ }
+ if (c == '\r') {
+ loc_t x;
+ x = ReadCommand(0x30) | (ReadCommand(0x31) << 8); // Left edge of active window
+ WriteCommandW(0x2A, x);
+ } else if (c == '\n') {
+ loc_t y;
+ y = ReadCommand(0x2C) | (ReadCommand(0x2D) << 8); // current y location
+ y += fontheight();
+ if (y >= height()) // @TODO after bottom of active window, then scroll window?
+ y = 0;
+ WriteCommandW(0x2C, y);
+ } else {
+ WriteCommand(0x02); // RA8875 Internal Fonts
+ _select(true);
+ WriteData(c);
+ _WaitWhileBusy(0x80);
+ _select(false);
+ }
+ }
+ return c;
+}
+
+
+RetCode_t RA8875::_StartGraphicsStream(void)
+{
+ WriteCommand(0x40,0x00); // Graphics write mode
+ WriteCommand(0x02); // Prepare for streaming data
+ return noerror;
+}
+
+
+RetCode_t RA8875::_EndGraphicsStream(void)
+{
+ return noerror;
+}
+
+
+RetCode_t RA8875::_putp(color_t pixel)
+{
+ WriteDataW((pixel>>8) | (pixel<<8));
+ return noerror;
+}
+
+
+void RA8875::puts(loc_t x, loc_t y, const char * string)
+{
+ SetTextCursor(x,y);
+ puts(string);
+}
+
+
+void RA8875::puts(const char * string)
+{
+ unsigned char mwcr0 = ReadCommand(0x40);
+
+ if (font == NULL) {
+ if ((mwcr0 & 0x80) == 0x00)
+ WriteCommand(0x40,0x80); // Put in Text mode if not already
+ } else {
+ _StartGraphicsStream();
+ }
+ if (*string != '\0') {
+#if 1
+ while (*string) { // @TODO calling individual _putc is slower... optimizations?
+ _putc(*string++);
+ }
+#else
+ WriteCommand(0x02);
+ _select(true);
+ while (*string != '\0') {
+ WriteData(*string);
+ ++string;
+ _WaitWhileBusy(0x80);
+ }
+ _select(false);
+#endif
+ }
+ if (font)
+ _EndGraphicsStream();
+}
+
+
+RetCode_t RA8875::SetGraphicsCursor(loc_t x, loc_t y)
+{
+ WriteCommandW(0x46, x);
+ WriteCommandW(0x48, y);
+ return noerror;
+}
+
+
+RetCode_t RA8875::SetGraphicsCursorRead(loc_t x, loc_t y)
+{
+ //WriteCommand(0x40, 0); // Graphics mode
+ //WriteCommand(0x45, 0); // left->right, top->bottom
+ WriteCommandW(0x4A, x);
+ WriteCommandW(0x4C, y);
+ return noerror;
+}
+
+
+RetCode_t RA8875::window(loc_t x, loc_t y, dim_t width, dim_t height)
+{
+ GraphicsDisplay::window(x,y, width,height);
+ WriteCommandW(0x30, x);
+ WriteCommandW(0x32, y);
+ WriteCommandW(0x34, (x+width-1));
+ WriteCommandW(0x36, (y+height-1));
+ SetGraphicsCursor(x,y);
+ return noerror;
+}
+
+
+RetCode_t RA8875::cls(uint16_t layers)
+{
+ RetCode_t ret;
+
+ PERFORMANCE_RESET;
+ if (layers == 0) {
+ ret = clsw(FULLWINDOW);
+ ret = SetTextCursor(0,0);
+ } else if (layers > 3) {
+ ret = bad_parameter;
+ } else {
+ uint16_t prevLayer = GetDrawingLayer();
+ if (layers & 1) {
+ SelectDrawingLayer(0);
+ clsw(FULLWINDOW);
+ }
+ if (layers & 2) {
+ SelectDrawingLayer(1);
+ clsw(FULLWINDOW);
+ }
+ ret = SelectDrawingLayer(prevLayer);
+ }
+ REGISTERPERFORMANCE(PRF_CLS);
+ return ret;
+}
+
+
+RetCode_t RA8875::clsw(RA8875::Region_t region)
+{
+ PERFORMANCE_RESET;
+ WriteCommand(0x8E, (region == ACTIVEWINDOW) ? 0xC0 : 0x80);
+ _WaitWhileReg(0x8E, 0x80);
+ REGISTERPERFORMANCE(PRF_CLS);
+ return noerror;
+}
+
+
+RetCode_t RA8875::pixel(loc_t x, loc_t y, color_t color)
+{
+ RetCode_t ret;
+
+ PERFORMANCE_RESET;
+#if 1
+ ret = pixelStream(&color, 1, x,y);
+#else
+ foreground(color);
+ ret = pixel(x,y);
+#endif
+ REGISTERPERFORMANCE(PRF_DRAWPIXEL);
+ return ret;
+}
+
+
+RetCode_t RA8875::pixel(loc_t x, loc_t y)
+{
+ RetCode_t ret;
+
+ PERFORMANCE_RESET;
+ color_t color = GetForeColor();
+#if 1
+ ret = pixelStream(&color, 1, x, y);
+#else
+ WriteCommand(0x40,0x00); // Graphics write mode
+ SetGraphicsCursor(x, y);
+ WriteCommand(0x02);
+ WriteDataW(color);
+ ret = noerror;
+#endif
+ REGISTERPERFORMANCE(PRF_DRAWPIXEL);
+ return ret;
+}
+
+
+RetCode_t RA8875::pixelStream(color_t * p, uint32_t count, loc_t x, loc_t y)
+{
+ PERFORMANCE_RESET;
+ WriteCommand(0x40,0x00); // Graphics write mode
+ SetGraphicsCursor(x, y);
+ WriteCommand(0x02);
+ _select(true);
+ _spiwrite(0x00); // Cmd: write data
+ while (count--) {
+ _spiwrite(*p >> 8);
+ _spiwrite(*p & 0xFF);
+ p++;
+ }
+ _select(false);
+ REGISTERPERFORMANCE(PRF_PIXELSTREAM);
+ return(noerror);
+}
+
+
+color_t RA8875::getPixel(loc_t x, loc_t y)
+{
+ color_t pixel;
+
+ PERFORMANCE_RESET;
+ //WriteCommand(0x45,0x00); // read left->right, top->bottom
+ WriteCommand(0x40,0x00); // Graphics write mode
+ SetGraphicsCursorRead(x, y);
+ WriteCommand(0x02);
+ _select(true);
+ _spiwrite(0x40); // Cmd: read data
+ _spiwrite(0x00); // dummy read
+ pixel = _spiread();
+ pixel |= (_spiread() << 8);
+ _select(false);
+ REGISTERPERFORMANCE(PRF_READPIXEL);
+ return pixel;
+}
+
+
+RetCode_t RA8875::getPixelStream(color_t * p, uint32_t count, loc_t x, loc_t y)
+{
+ color_t pixel;
+
+ PERFORMANCE_RESET;
+ //WriteCommand(0x45,0x00); // read left->right, top->bottom
+ WriteCommand(0x40,0x00); // Graphics write mode
+ SetGraphicsCursorRead(x, y);
+ WriteCommand(0x02);
+ _select(true);
+ _spiwrite(0x40); // Cmd: read data
+ _spiwrite(0x00); // dummy read
+ while (count--) {
+ pixel = _spiread();
+ pixel |= (_spiread() << 8);
+ *p++ = pixel;
+ }
+ _select(false);
+ REGISTERPERFORMANCE(PRF_READPIXELSTREAM);
+ return noerror;
+}
+
+
+RetCode_t RA8875::line(loc_t x1, loc_t y1, loc_t x2, loc_t y2, color_t color)
+{
+ foreground(color);
+ return line(x1,y1,x2,y2);
+}
+
+
+RetCode_t RA8875::line(loc_t x1, loc_t y1, loc_t x2, loc_t y2)
+{
+ PERFORMANCE_RESET;
+ if (x1 == x2 && y1 == y2) {
+ pixel(x1, y1);
+ } else {
+ WriteCommandW(0x91, x1);
+ WriteCommandW(0x93, y1);
+ WriteCommandW(0x95, x2);
+ WriteCommandW(0x97, y2);
+ unsigned char drawCmd = 0x00; // Line
+ WriteCommand(0x90, drawCmd);
+ WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
+ _WaitWhileReg(0x90, 0x80);
+ }
+ REGISTERPERFORMANCE(PRF_DRAWLINE);
+ return noerror;
+}
+
+RetCode_t RA8875::fillrect(rect_t r, color_t color, fill_t fillit)
+{
+ return rect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, color, fillit);
+}
+
+RetCode_t RA8875::fillrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
+ color_t color, fill_t fillit)
+{
+ return rect(x1,y1,x2,y2,color,fillit);
+}
+
+RetCode_t RA8875::rect(rect_t r, color_t color, fill_t fillit)
+{
+ return rect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, color, fillit);
+}
+
+RetCode_t RA8875::rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
+ color_t color, fill_t fillit)
+{
+ foreground(color);
+ return rect(x1,y1,x2,y2,fillit);
+}
+
+
+RetCode_t RA8875::rect(loc_t x1, loc_t y1, loc_t x2, loc_t 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 {
+ WriteCommandW(0x91, x1);
+ WriteCommandW(0x93, y1);
+ WriteCommandW(0x95, x2);
+ WriteCommandW(0x97, y2);
+ unsigned char drawCmd = 0x10; // Rectangle
+ if (fillit == FILL)
+ drawCmd |= 0x20;
+ WriteCommand(0x90, drawCmd);
+ WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
+ _WaitWhileReg(0x90, 0x80);
+ }
+ REGISTERPERFORMANCE(PRF_DRAWRECTANGLE);
+ return noerror;
+}
+
+
+RetCode_t RA8875::fillroundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
+ dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
+{
+ foreground(color);
+ return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
+}
+
+
+RetCode_t RA8875::roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
+ dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
+{
+ foreground(color);
+ return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
+}
+
+
+RetCode_t RA8875::roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
+ dim_t radius1, dim_t radius2, fill_t fillit)
+{
+ RetCode_t ret = noerror;
+
+ PERFORMANCE_RESET;
+ if (x1 > x2 || y1 > y2 || (radius1 > (x2-x1)/2) || (radius2 > (y2-y1)/2) ) {
+ ret = bad_parameter;
+ } else 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 {
+ WriteCommandW(0x91, x1);
+ WriteCommandW(0x93, y1);
+ WriteCommandW(0x95, x2);
+ WriteCommandW(0x97, y2);
+ WriteCommandW(0xA1, radius1);
+ WriteCommandW(0xA3, radius2);
+ // Should not need this...
+ WriteCommandW(0xA5, 0);
+ WriteCommandW(0xA7, 0);
+ unsigned char drawCmd = 0x20; // Rounded Rectangle
+ if (fillit == FILL)
+ drawCmd |= 0x40;
+ WriteCommand(0xA0, drawCmd);
+ WriteCommand(0xA0, 0x80 + drawCmd); // Start drawing.
+ _WaitWhileReg(0xA0, 0x80);
+ }
+ REGISTERPERFORMANCE(PRF_DRAWROUNDEDRECTANGLE);
+ return ret;
+}
+
+
+RetCode_t RA8875::triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
+ loc_t x3, loc_t y3, color_t color, fill_t fillit)
+{
+ RetCode_t ret;
+
+ foreground(color);
+ ret = triangle(x1,y1,x2,y2,x3,y3,fillit);
+ return ret;
+}
+
+
+RetCode_t RA8875::filltriangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
+ loc_t x3, loc_t y3, color_t color, fill_t fillit)
+{
+ RetCode_t ret;
+
+ foreground(color);
+ ret = triangle(x1,y1,x2,y2,x3,y3,fillit);
+ return ret;
+}
+
+
+RetCode_t RA8875::triangle(loc_t x1, loc_t y1 ,loc_t x2, loc_t y2,
+ loc_t x3, loc_t y3, fill_t fillit)
+{
+ RetCode_t ret = noerror;
+
+ PERFORMANCE_RESET;
+ if (x1 == x2 && y1 == y2 && x1 == x3 && y1 == y3) {
+ pixel(x1, y1);
+ } else {
+ WriteCommandW(0x91, x1);
+ WriteCommandW(0x93, y1);
+ WriteCommandW(0x95, x2);
+ WriteCommandW(0x97, y2);
+ WriteCommandW(0xA9, x3);
+ WriteCommandW(0xAB, y3);
+ unsigned char drawCmd = 0x01; // Triangle
+ if (fillit == FILL)
+ drawCmd |= 0x20;
+ WriteCommand(0x90, drawCmd);
+ WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
+ _WaitWhileReg(0x90, 0x80);
+ }
+ REGISTERPERFORMANCE(PRF_DRAWTRIANGLE);
+ return ret;
+}
+
+RetCode_t RA8875::circle(loc_t x, loc_t y, dim_t radius,
+ color_t color, fill_t fillit)
+{
+ foreground(color);
+ return circle(x,y,radius,fillit);
+}
+
+
+RetCode_t RA8875::fillcircle(loc_t x, loc_t y, dim_t radius,
+ color_t color, fill_t fillit)
+{
+ foreground(color);
+ return circle(x,y,radius,fillit);
+}
+
+
+RetCode_t RA8875::circle(loc_t x, loc_t y, dim_t radius, fill_t fillit)
+{
+ RetCode_t ret = noerror;
+
+ PERFORMANCE_RESET;
+ if (radius <= 0) {
+ ret = bad_parameter;
+ } else if (radius == 1) {
+ pixel(x,y);
+ } else {
+ WriteCommandW(0x99, x);
+ WriteCommandW(0x9B, y);
+ WriteCommand(0x9d, radius & 0xFF);
+ unsigned char drawCmd = 0x00; // Circle
+ if (fillit == FILL)
+ drawCmd |= 0x20;
+ WriteCommand(0x90, drawCmd);
+ WriteCommand(0x90, 0x40 + drawCmd); // Start drawing.
+ _WaitWhileReg(0x90, 0x40);
+ }
+ REGISTERPERFORMANCE(PRF_DRAWCIRCLE);
+ return ret;
+}
+
+
+RetCode_t RA8875::ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
+{
+ foreground(color);
+ return ellipse(x,y,radius1,radius2,fillit);
+}
+
+
+RetCode_t RA8875::fillellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
+{
+ foreground(color);
+ return ellipse(x,y,radius1,radius2,fillit);
+}
+
+
+RetCode_t RA8875::ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, fill_t fillit)
+{
+ RetCode_t ret = noerror;
+
+ PERFORMANCE_RESET;
+ if (radius1 <= 0 || radius2 <= 0) {
+ ; // do nothing
+ } else if (radius1 == 1 && radius2 == 1) {
+ pixel(x, y);
+ } else {
+ WriteCommandW(0xA5, x);
+ WriteCommandW(0xA7, y);
+ WriteCommandW(0xA1, radius1);
+ WriteCommandW(0xA3, radius2);
+ unsigned char drawCmd = 0x00; // Ellipse
+ if (fillit == FILL)
+ drawCmd |= 0x40;
+ WriteCommand(0xA0, drawCmd);
+ WriteCommand(0xA0, 0x80 + drawCmd); // Start drawing.
+ _WaitWhileReg(0xA0, 0x80);
+ }
+ REGISTERPERFORMANCE(PRF_DRAWELLIPSE);
+ return ret;
+}
+
+
+RetCode_t RA8875::frequency(unsigned long Hz, unsigned long Hz2)
+{
+ spiwritefreq = Hz;
+ if (Hz2 != 0)
+ spireadfreq = Hz2;
+ else
+ spireadfreq = Hz/2;
+ _setWriteSpeed(true);
+ // __ ___
+ // Clock ___A Rising edge latched
+ // ___ ____
+ // Data ___X____
+ spi.format(8, 3); // 8 bits and clock to data phase 0
+ return noerror;
+}
+
+void RA8875::_setWriteSpeed(bool writeSpeed)
+{
+ if (writeSpeed) {
+ spi.frequency(spiwritefreq);
+ spiWriteSpeed = true;
+ } else {
+ spi.frequency(spireadfreq);
+ spiWriteSpeed = false;
+ }
+}
+
+RetCode_t RA8875::Power(bool on)
+{
+ WriteCommand(0x01, (on) ? 0x80 : 0x00);
+ 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.0)
+ b = 0;
+ else
+ b = (unsigned char)(brightness * 255);
+ return Backlight_u8(b);
+}
+
+
+RetCode_t RA8875::set_font(const unsigned char * _font)
+{
+ if (font && ! _font) {
+ SetTextCursor(cursor_x, cursor_y); // soft-font cursor -> hw cursor
+ }
+ font = _font;
+ GraphicsDisplay::set_font(_font);
+ return noerror; // trusting them, but it might be good to put some checks in here...
+}
+
+
+RetCode_t RA8875::background(color_t color)
+{
+ GraphicsDisplay::background(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)
+{
+ background(RGB(r,g,b));
+// WriteCommand(0x60, r);
+// WriteCommand(0x61, g);
+// WriteCommand(0x62, b);
+ return noerror;
+}
+
+
+RetCode_t RA8875::foreground(color_t color)
+{
+ GraphicsDisplay::foreground(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 r, unsigned char g, unsigned char b)
+{
+ foreground(RGB(r,g,b));
+// WriteCommand(0x63, r);
+// WriteCommand(0x64, g);
+// WriteCommand(0x65, b);
+ return noerror;
+}
+
+
+color_t 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;
+
+ if (!spiWriteSpeed)
+ _setWriteSpeed(true);
+ retval = spi.write(data);
+ return retval;
+}
+
+
+unsigned char RA8875::_spiread(void)
+{
+ unsigned char retval;
+ unsigned char data = 0;
+
+ if (spiWriteSpeed)
+ _setWriteSpeed(false);
+ retval = spi.write(data);
+ return retval;
+}
+
+
+RetCode_t RA8875::_select(bool chipsel)
+{
+ cs = (chipsel == true) ? 0 : 1;
+ return noerror;
+}
+
+
+RetCode_t RA8875::PrintScreen(uint16_t layer, loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP)
+{
+#if 1
+ (void)layer;
+ return PrintScreen(x, y, w, h, Name_BMP);
+#else
+ // This is the deprecated interface and with the changes it is no longer implemented correctly.
+ uint16_t curLayer = GetDrawingLayer();
+ RetCode_t ret = SelectDrawingLayer(layer);
+ if (ret == noerror) {
+ ret = PrintScreen(x, y, w, h, Name_BMP);
+ }
+ SelectDrawingLayer(curLayer);
+ return ret;
+#endif
+}
+
+
+RetCode_t RA8875::PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP)
+{
+ BITMAPFILEHEADER BMP_Header;
+ BITMAPINFOHEADER BMP_Info;
+
+ INFO("(%d,%d) - (%d,%d) %s", x,y,w,h,Name_BMP);
+ if (x >= 0 && x < width()
+ && y >= 0 && y < height()
+ && w > 0 && x + w <= width()
+ && h > 0 && y + h <= height()) {
+
+ BMP_Header.bfType = BF_TYPE;
+ BMP_Header.bfSize = (w * h * sizeof(RGBQUAD)) + sizeof(BMP_Header) + sizeof(BMP_Header);
+ BMP_Header.bfReserved1 = 0;
+ BMP_Header.bfReserved2 = 0;
+ BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Header);
+
+ BMP_Info.biSize = sizeof(BMP_Info);
+ BMP_Info.biWidth = w;
+ BMP_Info.biHeight = h;
+ BMP_Info.biPlanes = 1;
+ BMP_Info.biBitCount = 24;
+ BMP_Info.biCompression = BI_RGB;
+ BMP_Info.biSizeImage = 0;
+ BMP_Info.biXPelsPerMeter = 0;
+ BMP_Info.biYPelsPerMeter = 0;
+ BMP_Info.biClrUsed = 0;
+ BMP_Info.biClrImportant = 0;
+
+ INFO("Writing {%s}", Name_BMP);
+ FILE *Image = fopen(Name_BMP, "wb");
+ if (!Image) {
+ ERR("File not found");
+ return(file_not_found);
+ }
+
+ // Be optimistic - don't check for errors.
+ //HexDump("BMP_Header", (uint8_t *)&BMP_Header, sizeof(BMP_Header));
+ fwrite(&BMP_Header, sizeof(char), sizeof(BMP_Header), Image);
+ //INFO("fwrite returned %d", r);
+
+ //HexDump("BMP_Info", (uint8_t *)&BMP_Info, sizeof(BMP_Info));
+ fwrite(&BMP_Info, sizeof(char), sizeof(BMP_Info), Image);
+ //INFO("fwrite returned %d", r);
+
+ int lineBufSize = ((24 * w + 7)/8);
+ uint8_t * lineBuffer = (uint8_t *)malloc(lineBufSize);
+ if (lineBuffer == NULL) {
+ fclose(Image);
+ ERR("Not enough RAM for lineBuffer");
+ return(not_enough_ram);
+ }
+ color_t * pixelBuffer = (color_t *)malloc(w * sizeof(color_t));
+ color_t * pixelBuffer2 = (color_t *)malloc(w * sizeof(color_t));
+ color_t transparency = GetBackgroundTransparencyColor();
+ unsigned char ltpr0 = ReadCommand(0x52) & 0x7;
+
+ if (pixelBuffer == NULL || pixelBuffer2 == NULL) {
+ fclose(Image);
+ free(lineBuffer);
+ ERR("Not enough RAM for pixelBuffer");
+ if (pixelBuffer)
+ free(pixelBuffer);
+ return(not_enough_ram);
+ }
+
+ uint16_t prevLayer = GetDrawingLayer();
+ // If only one of the layers is visible, select that layer
+ switch(ltpr0) {
+ case 0:
+ SelectDrawingLayer(0);
+ break;
+ case 1:
+ SelectDrawingLayer(1);
+ break;
+ default:
+ break;
+ }
+
+ // Read the display from the last line toward the top
+ // so we can write the file in one pass.
+ for (int j = h - 1; j >= 0; j--) {
+ if (ltpr0 >= 2) // Need to combine the layers...
+ SelectDrawingLayer(0); // so read layer 0 first
+ // Read one line of pixels to a local buffer
+ if (getPixelStream(pixelBuffer, w, x,y+j) != noerror) {
+ ERR("getPixelStream error, and no recovery handler...");
+ }
+ if (ltpr0 >= 2) { // Need to combine the layers...
+ SelectDrawingLayer(1); // so read layer 0 first
+ if (getPixelStream(pixelBuffer2, w, x,y+j) != noerror) {
+ ERR("getPixelStream error, and no recovery handler...");
+ }
+ }
+ // Convert the local buffer to RGBQUAD format
+ int lb = 0;
+ for (int i=0; i<w; i++) {
+ RGBQUAD q0 = RGB16ToRGBQuad(pixelBuffer[x+i]); // Scale to 24-bits
+ RGBQUAD q1 = RGB16ToRGBQuad(pixelBuffer2[x+i]); // Scale to 24-bits
+ switch (ltpr0) {
+ case 0:
+ case 1:
+ case 2: // lighten-overlay (@TODO Not supported yet)
+ case 6: // Floating Windows (@TODO not sure how to support)
+ default: // Reserved...
+ lineBuffer[lb++] = q0.rgbBlue;
+ lineBuffer[lb++] = q0.rgbGreen;
+ lineBuffer[lb++] = q0.rgbRed;
+ break;
+ case 3: // transparent mode (@TODO Read the background color register for transparent)
+ case 4: // boolean or
+ lineBuffer[lb++] = q0.rgbBlue | q1.rgbBlue;
+ lineBuffer[lb++] = q0.rgbGreen | q1.rgbGreen;
+ lineBuffer[lb++] = q0.rgbRed | q1.rgbRed;
+ break;
+ case 5: // boolean AND
+ lineBuffer[lb++] = q0.rgbBlue & q1.rgbBlue;
+ lineBuffer[lb++] = q0.rgbGreen & q1.rgbGreen;
+ lineBuffer[lb++] = q0.rgbRed & q1.rgbRed;
+ break;
+ }
+ }
+ if (j == h - 1)
+ HexDump("Line", lineBuffer, lineBufSize);
+ // Write to disk
+ fwrite(lineBuffer, sizeof(char), lb, Image);
+ }
+ SelectDrawingLayer(prevLayer);
+ fclose(Image);
+ free(pixelBuffer2); // don't leak memory.
+ free(pixelBuffer);
+ free(lineBuffer);
+ INFO("Image closed");
+ return noerror;
+ } else {
+ return bad_parameter;
+ }
+}
+
+
+// ##########################################################################
+// ##########################################################################
+// ##########################################################################
+
+#ifdef TESTENABLE
+
+#include "Arial12x12.h"
+#include "Small_6.h"
+
+// ______________ ______________ ______________ _______________
+// /_____ _____/ / ___________/ / ___________/ /_____ ______/
+// / / / / / / / /
+// / / / /___ / /__________ / /
+// / / / ____/ /__________ / / /
+// / / / / / / / /
+// / / / /__________ ___________/ / / /
+// /__/ /_____________/ /_____________/ /__/
+//
+// Everything from here down is test code.
+//
+bool SuppressSlowStuff = false;
+
+void TextWrapTest(RA8875 & display, Serial & pc)
+{
+ if (!SuppressSlowStuff)
+ pc.printf("Text Wrap Test\r\n");
+ display.background(Black);
+ display.foreground(Blue);
+ display.cls();
+ display.Backlight_u8(255);
+ display.puts(0,0, "Text Wrap Test.\r\n");
+ for (int i=1; i<60; i++) {
+ display.printf("L%2d\n", i % 17);
+ if (!SuppressSlowStuff)
+ wait_ms(100);
+ }
+ if (!SuppressSlowStuff)
+ wait_ms(3000);
+}
+
+
+void ShowKey(RA8875 & display, int key)
+{
+ loc_t col, row;
+ dim_t r1 = 25;
+ color_t color = (key & 0x80) ? Red : Green;
+
+ key &= 0x7F; // remove the long-press flag
+ row = (key - 1) / 5;
+ col = (key - 1) % 5;
+ if (col > 5) col = 5;
+ if (row > 4) row = 4;
+ display.circle(450 - + (2 * r1) * col, 200 - (2 * r1) * row, r1-2, color, FILL);
+}
+
+void HideKey(RA8875 & display, int key)
+{
+ loc_t col, row;
+ dim_t r1 = 25;
+
+ row = (key - 1) / 5;
+ col = (key - 1) % 5;
+ if (col > 5) col = 5;
+ if (row > 4) row = 4;
+ display.background(Black);
+ display.circle(450 - (2 * r1) * col, 200 - (2 * r1) * row, r1-2, Black, FILL);
+ display.circle(450 - (2 * r1) * col, 200 - (2 * r1) * row, r1-2, Blue);
+}
+
+void KeyPadTest(RA8875 & display, Serial & pc)
+{
+ const uint8_t myMap[22] = {
+ 0,
+ 'a', 'b', 'c', 'd', 'e',
+ 'f', 'g', 'h', 'i', 'j',
+ 'k', 'l', 'm', 'n', 'o',
+ 'p', 'q', 'r', 's', 't',
+ 'x'
+ };
+
+ display.background(Black);
+ display.foreground(Blue);
+ display.cls();
+ display.Backlight_u8(255);
+ display.puts(0,0, "KeyPad Test. Touch the keypad...");
+ pc.printf("\r\n"
+ "Raw KeyPad Test. Keypad returns the key-number.\r\n"
+ "Press [most] any PC keyboard key to advance to next test.\r\n");
+ RetCode_t ret = display.KeypadInit(true, true, 3, 7, 3);
+ if (ret != noerror)
+ pc.printf("returncode from KeypadInit is %d\r\n", ret);
+ int lastKey = 0;
+ while (!pc.readable()) {
+ if (display.readable()) {
+ int key = display.getc();
+ if (key) {
+ if (((key & 0x7F) != lastKey) && (lastKey != 0))
+ HideKey(display, lastKey);
+ ShowKey(display, key);
+ lastKey = key & 0x7F;
+ } else {
+ // erase the last one
+ if (lastKey)
+ HideKey(display, lastKey);
+ }
+ }
+ }
+ (void)pc.getc();
+ pc.printf("\r\n"
+ "Map KeyPad Test. Keypad returns the remapped key 'a' - 't'.\r\n"
+ "Press [most] any PC keyboard key to advance to exit test.\r\n");
+ display.SetKeyMap(myMap);
+ while (!pc.readable()) {
+ if (display.readable()) {
+ int key = display.getc();
+ bool longPress = key & 0x80;
+ display.SetTextCursor(0, 120);
+ display.printf("Long Press: %d\r\n", longPress);
+ display.printf(" Remapped: %c %02X\r\n", (key) ? key & 0x7F : ' ', key);
+ }
+ }
+ (void)pc.getc();
+ display.SetKeyMap();
+ pc.printf("\r\n");
+}
+
+void TextCursorTest(RA8875 & display, Serial & pc)
+{
+ const char * iCursor = "The I-Beam cursor should be visible for this text.\r\n";
+ const char * uCursor = "The Underscore cursor should be visible for this text.\r\n";
+ const char * bCursor = "The Block cursor should be visible for this text.\r\n";
+ const char * bbCursor = "The Blinking Block cursor should be visible for this text.\r\n";
+ const char * p;
+ int delay = 100;
+
+ if (!SuppressSlowStuff)
+ pc.printf("Text Cursor Test\r\n");
+ else
+ delay = 0;
+ display.background(Black);
+ display.foreground(Blue);
+ display.cls();
+ display.Backlight_u8(255);
+ display.puts(0,0, "Text Cursor Test.");
+
+ // visible, non-blinking
+ display.SetTextCursor(0,20);
+ display.SetTextCursorControl(RA8875::IBEAM, false);
+ p = iCursor;
+ while (*p) {
+ display._putc(*p++);
+ wait_ms(delay);
+ }
+
+ display.SetTextCursorControl(RA8875::UNDER, false);
+ p = uCursor;
+ while (*p) {
+ display._putc(*p++);
+ wait_ms(delay);
+ }
+
+ display.SetTextCursorControl(RA8875::BLOCK, false);
+ p = bCursor;
+ while (*p) {
+ display._putc(*p++);
+ wait_ms(delay);
+ }
+
+ display.SetTextCursorControl(RA8875::BLOCK, true);
+ p = bbCursor;
+ while (*p) {
+ display._putc(*p++);
+ wait_ms(delay);
+ }
+ wait_ms(delay * 20);
+ display.SetTextCursorControl(RA8875::NOCURSOR, false);
+}
+
+
+void BacklightTest(RA8875 & display, Serial & pc, float ramptime)
+{
+ char buf[60];
+ unsigned int w = (ramptime * 1000)/ 256;
+ int delay = 200;
+
+ if (!SuppressSlowStuff)
+ pc.printf("Backlight Test - ramp over %f sec.\r\n", ramptime);
+ else {
+ delay = 0;
+ w = 0;
+ }
+ display.Backlight_u8(0);
+ display.background(White);
+ display.foreground(Blue);
+ display.cls();
+ wait_ms(delay);
+ display.puts(0,0, "RA8875 Backlight Test - Ramp up.");
+ for (int i=0; i <= 255; i++) {
+ sprintf(buf, "%3d, %4d", i, w);
+ display.puts(100,100,buf);
+ display.Backlight_u8(i);
+ wait_ms(w);
+ }
+}
+
+
+void BacklightTest2(RA8875 & display, Serial & pc)
+{
+ int delay = 20;
+
+ if (!SuppressSlowStuff)
+ pc.printf("Backlight Test 2\r\n");
+ else
+ delay = 0;
+
+ // Dim it out at the end of the tests.
+ display.foreground(Blue);
+ display.puts(0,0, "Ramp Backlight down.");
+ // Ramp it off
+ for (int i=255; i != 0; i--) {
+ display.Backlight_u8(i);
+ wait_ms(delay);
+ }
+ display.Backlight_u8(0);
+}
+
+
+void ExternalFontTest(RA8875 & display, Serial & pc)
+{
+ if (!SuppressSlowStuff)
+ pc.printf("External Font Test\r\n");
+ display.background(Black);
+ display.foreground(Blue);
+ display.cls();
+ display.Backlight(1);
+ display.puts(0,0, "External Font Test.");
+
+ display.set_font(Small_6);
+ display.puts(0,30, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
+
+ display.set_font(Arial12x12);
+ display.puts("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
+ display.set_font(); // restore to internal
+
+ display.puts("Normal font again.");
+ //display.window(0,0, display.width(), display.height());
+}
+
+
+void DOSColorTest(RA8875 & display, Serial & pc)
+{
+ if (!SuppressSlowStuff)
+ pc.printf("DOS Color Test\r\n");
+ display.background(Black);
+ display.foreground(Blue);
+ display.cls();
+ display.puts(0,0, "DOS Colors - Fore");
+ display.puts(280,0, "Back");
+ display.background(Gray);
+ for (int i=0; i<16; i++) {
+ display.foreground(display.DOSColor(i));
+ display.puts(160, i*16, display.DOSColorNames(i));
+ display.background(Black);
+ }
+ display.foreground(White);
+ for (int i=0; i<16; i++) {
+ display.background(display.DOSColor(i));
+ display.puts(360, i*16, display.DOSColorNames(i));
+ display.foreground(White);
+ }
+}
+
+
+void WebColorTest(RA8875 & display, Serial & pc)
+{
+ if (!SuppressSlowStuff)
+ pc.printf("Web Color Test\r\n");
+ display.background(Black);
+ display.foreground(Blue);
+ display.window(0,0, display.width(), display.height());
+ display.cls();
+ display.SetTextFontSize(1,1);
+ display.puts(200,0, "Web Color Test");
+ display.SetTextCursor(0,0);
+ display.puts(" ");
+ for (int i=0; i<16; i++)
+ display.printf("%X", i&0xF);
+ display.puts("\r\n0 ");
+ for (int i=0; i<sizeof(WebColors)/sizeof(WebColors[0]); i++) {
+ display.background(WebColors[i]);
+ display.puts(" ");
+ if (i % 16 == 15 && i < 255) {
+ display.printf("\r\n%X ", ((i+1)/16));
+ }
+ }
+ display.SetTextFontSize(1,1);
+}
+
+
+void PixelTest(RA8875 & display, Serial & pc)
+{
+ int i, c, x, y;
+
+ if (!SuppressSlowStuff)
+ pc.printf("Pixel Test\r\n");
+ display.background(Black);
+ display.foreground(Blue);
+ display.cls();
+ display.puts(0,0, "Pixel Test");
+ for (i=0; i<1000; i++) {
+ x = rand() % 480;
+ y = 16 + rand() % (272-16);
+ c = rand() % 16;
+ //pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
+ display.pixel(x,y, display.DOSColor(c));
+ }
+}
+
+
+void LineTest(RA8875 & display, Serial & pc)
+{
+ int i, x, y, x2, y2;
+
+ if (!SuppressSlowStuff)
+ pc.printf("Line Test\r\n");
+ display.background(Black);
+ display.foreground(Blue);
+ display.cls();
+ display.puts(0,0, "Line Test");
+ for (i=0; i<16; i++) {
+ // Lines
+ x = rand() % 480;
+ y = rand() % 272;
+ x2 = rand() % 480;
+ y2 = rand() % 272;
+ display.line(x,y, x2,y2, display.DOSColor(i));
+ }
+ display.foreground(BrightRed);
+ display.foreground(BrightGreen);
+ display.foreground(BrightBlue);
+ display.line(55,50, 79,74, BrightRed);
+ display.line(57,50, 81,74, BrightGreen);
+ display.line(59,50, 83,74, BrightBlue);
+ // horz
+ display.line(30,40, 32,40, BrightRed);
+ display.line(30,42, 32,42, BrightGreen);
+ display.line(30,44, 32,44, BrightBlue);
+ // vert
+ display.line(20,40, 20,42, BrightRed);
+ display.line(22,40, 22,42, BrightGreen);
+ display.line(24,40, 24,42, BrightBlue);
+ // compare point to line-point
+ display.pixel(20,50, BrightRed);
+ display.pixel(22,50, BrightGreen);
+ display.pixel(24,50, BrightBlue);
+ display.line(20,52, 20,52, BrightRed);
+ display.line(22,52, 22,52, BrightGreen);
+ display.line(24,52, 24,52, BrightBlue);
+
+ // point
+ display.line(50,50, 50,50, Red);
+ display.line(52,52, 52,52, Green);
+ display.line(54,54, 54,54, Blue);
+ display.line(60,60, 60,60, BrightRed);
+ display.line(62,62, 62,62, BrightGreen);
+ display.line(64,64, 64,64, BrightBlue);
+ display.line(70,70, 70,70, DarkRed);
+ display.line(72,72, 72,72, DarkGreen);
+ display.line(74,74, 74,74, DarkBlue);
+}
+
+
+void RectangleTest(RA8875 & display, Serial & pc)
+{
+ int i, x1,y1, x2,y2;
+
+ if (!SuppressSlowStuff)
+ pc.printf("Rectangle Test\r\n");
+ display.background(Black);
+ display.foreground(Blue);
+ display.cls();
+ display.puts(0,0, "Rectangle Test");
+ for (i=0; i<16; i++) {
+ x1 = rand() % 240;
+ y1 = 50 + rand() % 200;
+ x2 = rand() % 240;
+ y2 = 50 + rand() % 200;
+ display.rect(x1,y1, x2,y2, display.DOSColor(i));
+
+ x1 = 240 + rand() % 240;
+ y1 = 50 + rand() % 200;
+ x2 = 240 + rand() % 240;
+ y2 = 50 + rand() % 200;
+ display.rect(x1,y1, x2,y2, FILL);
+ }
+}
+
+
+void LayerTest(RA8875 & display, Serial & pc)
+{
+ loc_t i, x1,y1, x2,y2, r1,r2;
+
+ if (!SuppressSlowStuff)
+ pc.printf("Layer Test\r\n");
+
+ display.SelectDrawingLayer(0);
+ display.background(Black);
+ display.foreground(Blue);
+ display.cls();
+ display.puts(0,0, "Layer 0");
+ for (i=0; i<16; i++) {
+ x1 = rand() % 240;
+ y1 = 50 + rand() % 200;
+ x2 = x1 + rand() % 100;
+ y2 = y1 + rand() % 100;
+ r1 = rand() % (x2 - x1)/2;
+ r2 = rand() % (y2 - y1)/2;
+ display.roundrect(x1,y1, x2,y2, r1,r2, display.DOSColor(i));
+ if (!SuppressSlowStuff)
+ wait_ms(20);
+ }
+ if (!SuppressSlowStuff)
+ wait_ms(1000);
+
+ display.SelectDrawingLayer(1);
+ display.background(Black);
+ display.foreground(Yellow);
+ display.cls();
+ display.puts(240,0, "Layer 1");
+ for (i=0; i<16; i++) {
+ x1 = 300 + rand() % 100;
+ y1 = 70 + rand() % 200;
+ r1 = rand() % min(y1 - 20, 100);
+ display.circle(x1,y1,r1, display.DOSColor(i));
+ if (!SuppressSlowStuff)
+ wait_ms(20);
+ }
+ display.SetLayerMode(RA8875::ShowLayer1); // Show it after the build-up
+ if (!SuppressSlowStuff)
+ wait_ms(2000);
+
+ display.SelectDrawingLayer(0);
+ display.SetLayerMode(RA8875::ShowLayer0); // Show Layer 0 again
+ if (!SuppressSlowStuff)
+ wait_ms(1000);
+ display.SetLayerMode(RA8875::TransparentMode); // Transparent mode
+ if (!SuppressSlowStuff)
+ wait_ms(1000);
+ for (i=0; i<=8; i++) {
+ display.SetLayerTransparency(i, 8-i);
+ if (!SuppressSlowStuff)
+ wait_ms(200);
+ }
+
+ // Restore before we exit
+ display.SetLayerTransparency(0, 0);
+ display.SetLayerMode(RA8875::ShowLayer0); // Restore to layer 0
+}
+
+
+void RoundRectTest(RA8875 & display, Serial & pc)
+{
+ loc_t i, x1,y1, x2,y2, r1,r2;
+
+ if (!SuppressSlowStuff)
+ pc.printf("Round Rectangle Test\r\n");
+ display.background(Black);
+ display.foreground(Blue);
+ display.cls();
+ display.puts(0,0, "Rounded Rectangle Test");
+
+ for (i=0; i<16; i++) {
+ x1 = rand() % 240;
+ y1 = 50 + rand() % 200;
+ x2 = x1 + rand() % 100;
+ y2 = y1 + rand() % 100;
+ r1 = rand() % (x2 - x1)/2;
+ r2 = rand() % (y2 - y1)/2;
+ display.roundrect(x1,y1, x2,y2, 5,8, display.DOSColor(i));
+
+ x1 = 240 + rand() % 240;
+ y1 = 50 + rand() % 200;
+ x2 = x1 + rand() % 100;
+ y2 = y1 + rand() % 100;
+ r1 = rand() % (x2 - x1)/2;
+ r2 = rand() % (y2 - y1)/2;
+ display.roundrect(x1,y1, x2,y2, r1,r2, FILL);
+ }
+}
+
+
+void TriangleTest(RA8875 & display, Serial & pc)
+{
+ int i, x1, y1, x2, y2, x3, y3;
+
+ if (!SuppressSlowStuff)
+ pc.printf("Triangle Test\r\n");
+ display.background(Black);
+ display.foreground(Blue);
+ display.cls();
+ display.puts(0,0, "Triangle Test");
+
+ x1 = 150;
+ y1 = 2;
+ x2 = 190;
+ y2 = 7;
+ x3 = 170;
+ y3 = 16;
+ display.triangle(x1,y1, x2,y2, x3,y3);
+
+ x1 = 200;
+ y1 = 2;
+ x2 = 240;
+ y2 = 7;
+ x3 = 220;
+ y3 = 16;
+ display.filltriangle(x1,y1, x2,y2, x3,y3, BrightRed);
+
+ x1 = 300;
+ y1 = 2;
+ x2 = 340;
+ y2 = 7;
+ x3 = 320;
+ y3 = 16;
+ display.triangle(x1,y1, x2,y2, x3,y3, NOFILL);
+
+ x1 = 400;
+ y1 = 2;
+ x2 = 440;
+ y2 = 7;
+ x3 = 420;
+ y3 = 16;
+ display.triangle(x1,y1, x2,y2, x3,y3, Blue);
+
+ for (i=0; i<16; i++) {
+ x1 = rand() % 240;
+ y1 = 50 + rand() % 200;
+ x2 = rand() % 240;
+ y2 = 50 + rand() % 200;
+ x3 = rand() % 240;
+ y3 = 50 + rand() % 200;
+ display.triangle(x1,y1, x2,y2, x3,y3, display.DOSColor(i));
+ x1 = 240 + rand() % 240;
+ y1 = 50 + rand() % 200;
+ x2 = 240 + rand() % 240;
+ y2 = 50 + rand() % 200;
+ x3 = 240 + rand() % 240;
+ y3 = 50 + rand() % 200;
+ display.triangle(x1,y1, x2,y2, x3,y3, FILL);
+ }
+}
+
+
+void CircleTest(RA8875 & display, Serial & pc)
+{
+ int i, x, y, r1;
+
+ if (!SuppressSlowStuff)
+ pc.printf("Circle Test\r\n");
+ display.background(Black);
+ display.foreground(Blue);
+ display.cls();
+ display.puts(0,0, "Circle Test");
+ for (i=0; i<16; i++) {
+ x = 100 + rand() % 100;
+ y = 70 + rand() % 200;
+ r1 = rand() % min(y - 20, 100);
+ //pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
+ display.circle(x,y,r1, display.DOSColor(i));
+
+ x = 300 + rand() % 100;
+ y = 70 + rand() % 200;
+ r1 = rand() % min(y - 20, 100);
+ //pc.printf(" (%d,%d) - %d FILL\r\n", x,y,r1);
+ display.circle(x,y,r1, display.DOSColor(i), FILL);
+ }
+}
+
+
+void EllipseTest(RA8875 & display, Serial & pc)
+{
+ int i,x,y,r1,r2;
+
+ if (!SuppressSlowStuff)
+ pc.printf("Ellipse Test\r\n");
+ display.background(Black);
+ display.foreground(Blue);
+ display.cls();
+ display.puts(0,0, "Ellipse Test");
+ for (i=0; i<16; i++) {
+ x = 100 + rand() % 100;
+ y = 70 + rand() % 200;
+ r1 = rand() % min(y - 20, 100);
+ r2 = rand() % min(y - 20, 100);
+ display.ellipse(x,y,r1,r2, display.DOSColor(i));
+
+ x = 300 + rand() % 100;
+ y = 70 + rand() % 200;
+ r1 = rand() % min(y - 20, 100);
+ r2 = rand() % min(y - 20, 100);
+ display.ellipse(x,y,r1,r2, FILL);
+ }
+}
+
+
+void TestGraphicsBitmap(RA8875 & display, Serial & pc)
+{
+ LocalFileSystem local("local");
+ if (!SuppressSlowStuff)
+ pc.printf("Bitmap File Load\r\n");
+ display.background(Black);
+ display.foreground(Blue);
+ display.cls();
+ display.puts(0,0, "Graphics Test, loading /local/TestPat.bmp");
+ wait(3);
+
+ int r = display.RenderBitmapFile(0,0, "/local/TestPat.bmp");
+ if (!SuppressSlowStuff)
+ pc.printf(" returned %d\r\n", r);
+}
+
+
+void TouchPanelTest(RA8875 & display, Serial & pc)
+{
+ Timer t;
+ loc_t x, y;
+ tpMatrix_t calmatrix;
+
+ display.background(Black);
+ display.foreground(Blue);
+ display.cls();
+ display.puts(0,0, "Touch Panel Test\r\n");
+ pc.printf("Touch Panel Test\r\n");
+ display.TouchPanelInit();
+ pc.printf(" TP: c - calibrate, r - restore, t - test\r\n");
+ int c = pc.getc();
+ if (c == 'c') {
+ point_t pTest[3] =
+ { { 50, 50 }, {450, 150}, {225,250} };
+ point_t pSample[3];
+ for (int i=0; i<3; i++) {
+ display.foreground(Blue);
+ display.printf(" (%3d,%3d) => ", pTest[i].x, pTest[i].y);
+ display.line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, White);
+ display.line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, White);
+ while (!display.TouchPanelA2DFiltered(&x, &y))
+ wait_ms(20);
+ pSample[i].x = x;
+ pSample[i].y = y;
+ display.line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, Black);
+ display.line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, Black);
+ display.foreground(Blue);
+ display.printf(" (%4d,%4d)\r\n", x,y);
+ while (display.TouchPanelA2DFiltered(&x, &y))
+ wait_ms(20);
+ wait(2);
+ }
+ display.TouchPanelComputeCalibration(pTest, pSample, &calmatrix);
+ display.printf(" Writing calibration to tpcal.cfg\r\n");
+ FILE * fh = fopen("/local/tpcal.cfg", "wb");
+ if (fh) {
+ fwrite(&calmatrix, sizeof(calmatrix), 1, fh);
+ fclose(fh);
+ }
+ display.printf(" Calibration is complete.");
+ } else if (c == 'r') {
+ display.printf(" Reading calibration from tpcal.cfg\r\n");
+ FILE * fh = fopen("/local/tpcal.cfg", "rb");
+ if (fh) {
+ fread(&calmatrix, sizeof(calmatrix), 1, fh);
+ fclose(fh);
+ }
+ display.printf(" Calibration is complete.");
+ display.TouchPanelSetMatrix(&calmatrix);
+ }
+ t.start();
+ do {
+ point_t point = {0, 0};
+ if (display.TouchPanelReadable(&point)) {
+ display.pixel(point.x, point.y, Red);
+ }
+ } while (t.read_ms() < 30000);
+ pc.printf(">");
+}
+
+
+void SpeedTest(RA8875 & display, Serial & pc)
+{
+ Timer t;
+ SuppressSlowStuff = true;
+ pc.printf("\r\nSpeedTest disables delays, runs tests, reports overall time.\r\n");
+ t.start();
+ // do stuff fast
+ TextCursorTest(display, pc);
+ TextWrapTest(display, pc);
+ BacklightTest(display, pc, 0);
+ BacklightTest2(display, pc);
+ ExternalFontTest(display, pc);
+ DOSColorTest(display, pc);
+ WebColorTest(display, pc);
+ PixelTest(display, pc);
+ LineTest(display, pc);
+ RectangleTest(display, pc);
+ RoundRectTest(display, pc);
+ TriangleTest(display, pc);
+ CircleTest(display, pc);
+ EllipseTest(display, pc);
+ LayerTest(display, pc);
+ //TestGraphicsBitmap(display, pc);
+ pc.printf("SpeedTest completed in %d msec\r\n", t.read_ms());
+#ifdef PERF_METRICS
+ display.ReportPerformance(pc);
+#endif
+ SuppressSlowStuff = false;
+}
+
+
+void PrintScreen(RA8875 & display, Serial & pc)
+{
+ if (!SuppressSlowStuff)
+ pc.printf("PrintScreen\r\n");
+ display.PrintScreen( 0,0, 480,272, "/local/Capture.bmp");
+}
+
+
+void RunTestSet(RA8875 & lcd, Serial & pc)
+{
+ int q = 0;
+ int automode = 0;
+ const unsigned char modelist[] = "BDWtGLlFROTPCEbw"; // auto-test in this order.
+
+ while(1) {
+ pc.printf("\r\n"
+ "B - Backlight up b - backlight dim\r\n"
+ "D - DOS Colors W - Web Colors\r\n"
+ "t - text cursor G - Graphics Bitmap\r\n"
+ "L - Lines F - external Font\r\n"
+ "R - Rectangles O - rOund rectangles\r\n"
+ "T - Triangles P - Pixels \r\n"
+ "C - Circles E - Ellipses\r\n"
+ "A - Auto Test mode S - Speed Test\r\n"
+ "K - Keypad Test s - touch screen test\r\n"
+ "p - print screen r - reset \r\n"
+ "l - layer test w - wrapping text \r\n"
+#ifdef PERF_METRICS
+ "0 - clear performance 1 - report performance\r\n"
+#endif
+ "> ");
+ if (automode == -1 || pc.readable()) {
+ automode = -1;
+ q = pc.getc();
+ while (pc.readable())
+ pc.getc();
+ } else if (automode >= 0) {
+ q = modelist[automode];
+ }
+ switch(q) {
+#ifdef PERF_METRICS
+ case '0':
+ lcd.ClearPerformance();
+ break;
+ case '1':
+ lcd.ReportPerformance(pc);
+ break;
+#endif
+ case 'A':
+ automode = 0;
+ break;
+ case 'B':
+ BacklightTest(lcd, pc, 2);
+ break;
+ case 'b':
+ BacklightTest2(lcd, pc);
+ break;
+ case 'D':
+ DOSColorTest(lcd, pc);
+ break;
+ case 'K':
+ KeyPadTest(lcd, pc);
+ break;
+ case 'W':
+ WebColorTest(lcd, pc);
+ break;
+ case 't':
+ TextCursorTest(lcd, pc);
+ break;
+ case 'w':
+ TextWrapTest(lcd, pc);
+ break;
+ case 'F':
+ ExternalFontTest(lcd, pc);
+ break;
+ case 'L':
+ LineTest(lcd, pc);
+ break;
+ case 'l':
+ LayerTest(lcd, pc);
+ break;
+ case 'R':
+ RectangleTest(lcd, pc);
+ break;
+ case 'O':
+ RoundRectTest(lcd, pc);
+ break;
+ case 'p':
+ PrintScreen(lcd, pc);
+ break;
+ case 'S':
+ SpeedTest(lcd, pc);
+ break;
+ case 's':
+ TouchPanelTest(lcd, pc);
+ break;
+ case 'T':
+ TriangleTest(lcd, pc);
+ break;
+ case 'P':
+ PixelTest(lcd, pc);
+ break;
+ case 'G':
+ TestGraphicsBitmap(lcd, pc);
+ break;
+ case 'C':
+ CircleTest(lcd, pc);
+ break;
+ case 'E':
+ EllipseTest(lcd, pc);
+ break;
+ case 'r':
+ pc.printf("Resetting ...\r\n");
+ wait_ms(20);
+ mbed_reset();
+ break;
+ case ' ':
+ break;
+ default:
+ printf("huh?\n");
+ break;
+ }
+ if (automode >= 0) {
+ automode++;
+ if (automode >= sizeof(modelist))
+ automode = 0;
+ wait_ms(2000);
+ }
+ wait_ms(200);
+ }
+}
+
+#endif // TESTENABLE