David Smart / RA8875 Featured

Library to control a Graphics TFT connected to 4-wire SPI - revised for the Raio RA8875 Display Controller.

Dependents:   FRDM_RA8875_mPaint RA8875_Demo RA8875_KeyPadDemo SignalGenerator ... more

Fork of SPI_TFT by Peter Drescher

See Components - RA8875 Based Display

Enhanced touch-screen support - where it previous supported both the Resistive Touch and Capacitive Touch based on the FT5206 Touch Controller, now it also has support for the GSL1680 Touch Controller.

Offline Help Manual (Windows chm)

/media/uploads/WiredHome/ra8875.zip.bin (download, rename to .zip and unzip)

RA8875.cpp@135:af519fe4ba91, 2016-11-13 (annotated)

Committer:
WiredHome
Date:
Sun Nov 13 02:06:30 2016 +0000
Revision:
135:af519fe4ba91
Parent:
134:f028ed71a0af
Child:
136:224e03d5c31f
cls resets the cursor

Who changed what in which revision?

UserRevisionLine numberNew contents of line
WiredHome 19:3f82c1161fd2 1 /// RA8875 Display Controller Library.
WiredHome 73:f22a18707b5e 2 ///
WiredHome 68:ab08efabfc88 3 /// This is being created for a Raio RA8875-based display from buydisplay.com,
WiredHome 80:cc4fab58179c 4 /// which is 480 x 272 using a 4-wire SPI interface. Support is provided for
WiredHome 80:cc4fab58179c 5 /// both a keypad and a resistive touch-screen.
WiredHome 80:cc4fab58179c 6 ///
WiredHome 134:f028ed71a0af 7 /// This driver has been fully tested with an 800 x 480 variant (also using
WiredHome 133:e36dcfc2d756 8 /// 4-wire SPI).
WiredHome 19:3f82c1161fd2 9 ///
WiredHome 134:f028ed71a0af 10 /// 20161106: Updated the initialization to set the various registers based on
WiredHome 134:f028ed71a0af 11 /// the BuyDisplay.com example code. This altered several registers
WiredHome 134:f028ed71a0af 12 /// for the 800x480 display driver.
WiredHome 134:f028ed71a0af 13 ///
WiredHome 19:3f82c1161fd2 14 #include "RA8875.h"
WiredHome 19:3f82c1161fd2 15
WiredHome 41:2956a0a221e5 16 //#define DEBUG "RAIO"
WiredHome 19:3f82c1161fd2 17 // ...
WiredHome 19:3f82c1161fd2 18 // INFO("Stuff to show %d", var); // new-line is automatically appended
WiredHome 19:3f82c1161fd2 19 //
WiredHome 19:3f82c1161fd2 20 #if (defined(DEBUG) && !defined(TARGET_LPC11U24))
WiredHome 98:ecebed9b80b2 21 #define INFO(x, ...) std::printf("[INF %s %4d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome 98:ecebed9b80b2 22 #define WARN(x, ...) std::printf("[WRN %s %4d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome 98:ecebed9b80b2 23 #define ERR(x, ...) std::printf("[ERR %s %4d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome 98:ecebed9b80b2 24 static void HexDump(const char * title, const uint8_t * p, int count)
WiredHome 73:f22a18707b5e 25 {
WiredHome 73:f22a18707b5e 26 int i;
WiredHome 73:f22a18707b5e 27 char buf[100] = "0000: ";
WiredHome 73:f22a18707b5e 28
WiredHome 73:f22a18707b5e 29 if (*title)
WiredHome 73:f22a18707b5e 30 INFO("%s", title);
WiredHome 73:f22a18707b5e 31 for (i=0; i<count; ) {
WiredHome 73:f22a18707b5e 32 sprintf(buf + strlen(buf), "%02X ", *(p+i));
WiredHome 73:f22a18707b5e 33 if ((++i & 0x0F) == 0x00) {
WiredHome 73:f22a18707b5e 34 INFO("%s", buf);
WiredHome 73:f22a18707b5e 35 if (i < count)
WiredHome 73:f22a18707b5e 36 sprintf(buf, "%04X: ", i);
WiredHome 73:f22a18707b5e 37 else
WiredHome 73:f22a18707b5e 38 buf[0] = '\0';
WiredHome 73:f22a18707b5e 39 }
WiredHome 73:f22a18707b5e 40 }
WiredHome 73:f22a18707b5e 41 if (strlen(buf))
WiredHome 73:f22a18707b5e 42 INFO("%s", buf);
WiredHome 73:f22a18707b5e 43 }
WiredHome 19:3f82c1161fd2 44 #else
WiredHome 19:3f82c1161fd2 45 #define INFO(x, ...)
WiredHome 19:3f82c1161fd2 46 #define WARN(x, ...)
WiredHome 19:3f82c1161fd2 47 #define ERR(x, ...)
WiredHome 73:f22a18707b5e 48 #define HexDump(a, b, c)
WiredHome 19:3f82c1161fd2 49 #endif
WiredHome 19:3f82c1161fd2 50
WiredHome 109:7b94f06f085b 51 // Defaults. Users can override this with the init() method.
WiredHome 19:3f82c1161fd2 52 #define RA8875_DISPLAY_WIDTH 480
WiredHome 19:3f82c1161fd2 53 #define RA8875_DISPLAY_HEIGHT 272
WiredHome 43:3becae133285 54 #define RA8875_COLORDEPTH_BPP 16 /* Not an API */
WiredHome 19:3f82c1161fd2 55
WiredHome 19:3f82c1161fd2 56 #ifdef PERF_METRICS
WiredHome 19:3f82c1161fd2 57 #define PERFORMANCE_RESET performance.reset()
WiredHome 19:3f82c1161fd2 58 #define REGISTERPERFORMANCE(a) RegisterPerformance(a)
WiredHome 68:ab08efabfc88 59 #define COUNTIDLETIME(a) CountIdleTime(a)
WiredHome 73:f22a18707b5e 60 static const char *metricsName[] = {
WiredHome 109:7b94f06f085b 61 "Cls", "Pixel", "Pixel Stream", "Boolean Stream",
WiredHome 41:2956a0a221e5 62 "Read Pixel", "Read Pixel Stream",
WiredHome 73:f22a18707b5e 63 "Line",
WiredHome 73:f22a18707b5e 64 "Rectangle", "Rounded Rectangle",
WiredHome 68:ab08efabfc88 65 "Triangle", "Circle", "Ellipse"
WiredHome 19:3f82c1161fd2 66 };
WiredHome 91:ca5f829e6d27 67 uint16_t commandsUsed[256]; // track which commands are used with simple counter of number of hits.
WiredHome 19:3f82c1161fd2 68 #else
WiredHome 19:3f82c1161fd2 69 #define PERFORMANCE_RESET
WiredHome 19:3f82c1161fd2 70 #define REGISTERPERFORMANCE(a)
WiredHome 68:ab08efabfc88 71 #define COUNTIDLETIME(a)
WiredHome 19:3f82c1161fd2 72 #endif
WiredHome 19:3f82c1161fd2 73
WiredHome 73:f22a18707b5e 74 // When it is going to poll a register for completion, how many
WiredHome 19:3f82c1161fd2 75 // uSec should it wait between each polling activity.
WiredHome 19:3f82c1161fd2 76 #define POLLWAITuSec 10
WiredHome 19:3f82c1161fd2 77
WiredHome 75:ca78388cfd77 78 // Private RawKeyMap for the Keyboard interface
WiredHome 79:544eb4964795 79 static const uint8_t DefaultKeyMap[22] = {
WiredHome 77:9206c13aa527 80 0,
WiredHome 77:9206c13aa527 81 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
WiredHome 75:ca78388cfd77 82 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
WiredHome 75:ca78388cfd77 83 255
WiredHome 77:9206c13aa527 84 };
WiredHome 75:ca78388cfd77 85
WiredHome 79:544eb4964795 86 static const char * ErrMessages[] = {
WiredHome 79:544eb4964795 87 "noerror", ///< no errors, command completed successfully
WiredHome 89:04575562c961 88 "bad parameter", ///< one or more parameters are invalid
WiredHome 89:04575562c961 89 "file not found", ///< specified file could not be found
WiredHome 89:04575562c961 90 "not bmp format", ///< file is not a .bmp file
WiredHome 89:04575562c961 91 "not ico format", ///< file is not a .ico file
WiredHome 89:04575562c961 92 "not supported format", ///< file format is not yet supported
WiredHome 89:04575562c961 93 "image too big", ///< image is too large for the screen
WiredHome 89:04575562c961 94 "not enough ram", ///< could not allocate ram for scanline
WiredHome 125:7a0b70f56550 95 "touch cal. timeout", ///< calibration could not complete in time
WiredHome 125:7a0b70f56550 96 "external abort", ///< during an idle callback, the user code initiated an abort
WiredHome 79:544eb4964795 97 };
WiredHome 19:3f82c1161fd2 98
WiredHome 124:1690a7ae871c 99 RA8875::RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset,
WiredHome 124:1690a7ae871c 100 const char *name)
WiredHome 58:26658a56112a 101 : GraphicsDisplay(name)
WiredHome 58:26658a56112a 102 , spi(mosi, miso, sclk)
WiredHome 19:3f82c1161fd2 103 , cs(csel)
WiredHome 19:3f82c1161fd2 104 , res(reset)
WiredHome 19:3f82c1161fd2 105 {
WiredHome 124:1690a7ae871c 106 useTouchPanel = TP_NONE;
WiredHome 124:1690a7ae871c 107 m_irq = NULL;
WiredHome 124:1690a7ae871c 108 m_i2c = NULL;
WiredHome 96:40b74dd3695b 109 c_callback = NULL;
WiredHome 96:40b74dd3695b 110 obj_callback = NULL;
WiredHome 96:40b74dd3695b 111 method_callback = NULL;
WiredHome 123:2f45e80fec5f 112 idle_callback = NULL;
WiredHome 19:3f82c1161fd2 113 }
WiredHome 19:3f82c1161fd2 114
WiredHome 124:1690a7ae871c 115
WiredHome 124:1690a7ae871c 116 RA8875::RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset,
WiredHome 124:1690a7ae871c 117 PinName sda, PinName scl, PinName irq, const char * name)
WiredHome 124:1690a7ae871c 118 : GraphicsDisplay(name)
WiredHome 124:1690a7ae871c 119 , spi(mosi, miso, sclk)
WiredHome 124:1690a7ae871c 120 , cs(csel)
WiredHome 124:1690a7ae871c 121 , res(reset)
WiredHome 124:1690a7ae871c 122 {
WiredHome 124:1690a7ae871c 123 useTouchPanel = TP_CAP;
WiredHome 124:1690a7ae871c 124 m_irq = new InterruptIn(irq);
WiredHome 124:1690a7ae871c 125 m_i2c = new I2C(sda, scl);
WiredHome 124:1690a7ae871c 126 c_callback = NULL;
WiredHome 124:1690a7ae871c 127 obj_callback = NULL;
WiredHome 124:1690a7ae871c 128 method_callback = NULL;
WiredHome 124:1690a7ae871c 129 idle_callback = NULL;
WiredHome 124:1690a7ae871c 130
WiredHome 124:1690a7ae871c 131 // Cap touch panel config
WiredHome 124:1690a7ae871c 132 m_addr = (FT5206_I2C_ADDRESS << 1);
WiredHome 124:1690a7ae871c 133 m_i2c->frequency(FT5206_I2C_FREQUENCY);
WiredHome 124:1690a7ae871c 134
WiredHome 124:1690a7ae871c 135 // Interrupt
WiredHome 124:1690a7ae871c 136 m_irq->mode(PullUp);
WiredHome 124:1690a7ae871c 137 m_irq->enable_irq();
WiredHome 124:1690a7ae871c 138 m_irq->fall(this, &RA8875::TouchPanelISR);
WiredHome 124:1690a7ae871c 139 TouchPanelInit();
WiredHome 124:1690a7ae871c 140 }
WiredHome 124:1690a7ae871c 141
WiredHome 124:1690a7ae871c 142
WiredHome 19:3f82c1161fd2 143 //RA8875::~RA8875()
WiredHome 19:3f82c1161fd2 144 //{
WiredHome 19:3f82c1161fd2 145 //}
WiredHome 19:3f82c1161fd2 146
WiredHome 131:5bd6ba2ee4a1 147 RetCode_t RA8875::init(int width, int height, int color_bpp, uint8_t poweron, bool keypadon, bool touchscreenon)
WiredHome 79:544eb4964795 148 {
WiredHome 98:ecebed9b80b2 149 font = NULL; // no external font, use internal.
WiredHome 98:ecebed9b80b2 150 pKeyMap = DefaultKeyMap; // set default key map
WiredHome 98:ecebed9b80b2 151 _select(false); // deselect the display
WiredHome 98:ecebed9b80b2 152 frequency(RA8875_DEFAULT_SPI_FREQ); // data rate
WiredHome 79:544eb4964795 153 Reset();
WiredHome 134:f028ed71a0af 154 // Set PLL based on display size from buy-display.com sample code
WiredHome 134:f028ed71a0af 155 if (width == 800) {
WiredHome 134:f028ed71a0af 156 WriteCommand(0x88, 0x0C); // PLLC1 - Phase Lock Loop registers
WiredHome 134:f028ed71a0af 157 } else {
WiredHome 134:f028ed71a0af 158 WriteCommand(0x88, 0x0B); // PLLC1 - Phase Lock Loop registers
WiredHome 134:f028ed71a0af 159 }
WiredHome 79:544eb4964795 160 wait_ms(1);
WiredHome 79:544eb4964795 161 WriteCommand(0x89, 0x02);
WiredHome 79:544eb4964795 162 wait_ms(1);
WiredHome 79:544eb4964795 163
WiredHome 79:544eb4964795 164 // System Config Register (SYSR)
WiredHome 105:4f116006ba1f 165 screenbpp = color_bpp;
WiredHome 79:544eb4964795 166 if (color_bpp == 16) {
WiredHome 79:544eb4964795 167 WriteCommand(0x10, 0x0C); // 16-bpp (65K colors) color depth, 8-bit interface
WiredHome 79:544eb4964795 168 } else { // color_bpp == 8
WiredHome 79:544eb4964795 169 WriteCommand(0x10, 0x00); // 8-bpp (256 colors)
WiredHome 79:544eb4964795 170 }
WiredHome 134:f028ed71a0af 171
WiredHome 134:f028ed71a0af 172 // Set Pixel Clock Setting Register (PCSR) based on display size from buy-display.com sample code
WiredHome 134:f028ed71a0af 173 if (width == 800) {
WiredHome 134:f028ed71a0af 174 WriteCommand(0x04, 0x81); // PDAT on PCLK falling edge, PCLK = 4 x System Clock
WiredHome 134:f028ed71a0af 175 wait_ms(1);
WiredHome 134:f028ed71a0af 176
WiredHome 134:f028ed71a0af 177 // Horizontal Settings
WiredHome 134:f028ed71a0af 178 screenwidth = width;
WiredHome 134:f028ed71a0af 179 WriteCommand(0x14, width/8 - 1); //HDWR//Horizontal Display Width Setting Bit[6:0]
WiredHome 134:f028ed71a0af 180 WriteCommand(0x15, 0x00); //HNDFCR//Horizontal Non-Display Period fine tune Bit[3:0]
WiredHome 134:f028ed71a0af 181 WriteCommand(0x16, 0x03); //HNDR//Horizontal Non-Display Period Bit[4:0]
WiredHome 134:f028ed71a0af 182 WriteCommand(0x17, 0x03); //HSTR//HSYNC Start Position[4:0]
WiredHome 134:f028ed71a0af 183 WriteCommand(0x18, 0x0B); //HPWR//HSYNC Polarity ,The period width of HSYNC.
WiredHome 134:f028ed71a0af 184
WiredHome 134:f028ed71a0af 185 // Vertical Settings
WiredHome 134:f028ed71a0af 186 screenheight = height;
WiredHome 134:f028ed71a0af 187 WriteCommand(0x19, (height-1)&0xFF); //VDHR0 //Vertical Display Height Bit [7:0]
WiredHome 134:f028ed71a0af 188 WriteCommand(0x1a, (height-1)>>8); //VDHR1 //Vertical Display Height Bit [8]
WiredHome 134:f028ed71a0af 189 WriteCommand(0x1b, 0x20); //VNDR0 //Vertical Non-Display Period Bit [7:0]
WiredHome 134:f028ed71a0af 190 WriteCommand(0x1c, 0x00); //VNDR1 //Vertical Non-Display Period Bit [8]
WiredHome 134:f028ed71a0af 191 WriteCommand(0x1d, 0x16); //VSTR0 //VSYNC Start Position[7:0]
WiredHome 134:f028ed71a0af 192 WriteCommand(0x1e, 0x00); //VSTR1 //VSYNC Start Position[8]
WiredHome 134:f028ed71a0af 193 WriteCommand(0x1f, 0x01); //VPWR //VSYNC Polarity ,VSYNC Pulse Width[6:0]
WiredHome 134:f028ed71a0af 194 } else {
WiredHome 134:f028ed71a0af 195 WriteCommand(0x04, 0x82); // PDAT on PCLK falling edge, PCLK = 4 x System Clock
WiredHome 134:f028ed71a0af 196 wait_ms(1);
WiredHome 134:f028ed71a0af 197
WiredHome 134:f028ed71a0af 198 // Horizontal Settings
WiredHome 134:f028ed71a0af 199 screenwidth = width;
WiredHome 134:f028ed71a0af 200 WriteCommand(0x14, width/8 - 1); //HDWR//Horizontal Display Width Setting Bit[6:0]
WiredHome 134:f028ed71a0af 201 WriteCommand(0x15, 0x02); //HNDFCR//Horizontal Non-Display Period fine tune Bit[3:0]
WiredHome 134:f028ed71a0af 202 WriteCommand(0x16, 0x03); //HNDR//Horizontal Non-Display Period Bit[4:0]
WiredHome 134:f028ed71a0af 203 WriteCommand(0x17, 0x01); //HSTR//HSYNC Start Position[4:0]
WiredHome 134:f028ed71a0af 204 WriteCommand(0x18, 0x03); //HPWR//HSYNC Polarity ,The period width of HSYNC.
WiredHome 134:f028ed71a0af 205
WiredHome 134:f028ed71a0af 206 // Vertical Settings
WiredHome 134:f028ed71a0af 207 screenheight = height;
WiredHome 134:f028ed71a0af 208 WriteCommand(0x19, (height-1)&0xFF); //VDHR0 //Vertical Display Height Bit [7:0]
WiredHome 134:f028ed71a0af 209 WriteCommand(0x1a, (height-1)>>8); //VDHR1 //Vertical Display Height Bit [8]
WiredHome 134:f028ed71a0af 210 WriteCommand(0x1b, 0x0F); //VNDR0 //Vertical Non-Display Period Bit [7:0]
WiredHome 134:f028ed71a0af 211 WriteCommand(0x1c, 0x00); //VNDR1 //Vertical Non-Display Period Bit [8]
WiredHome 134:f028ed71a0af 212 WriteCommand(0x1d, 0x0e); //VSTR0 //VSYNC Start Position[7:0]
WiredHome 134:f028ed71a0af 213 WriteCommand(0x1e, 0x06); //VSTR1 //VSYNC Start Position[8]
WiredHome 134:f028ed71a0af 214 WriteCommand(0x1f, 0x01); //VPWR //VSYNC Polarity ,VSYNC Pulse Width[6:0]
WiredHome 134:f028ed71a0af 215 }
WiredHome 79:544eb4964795 216
WiredHome 100:0b084475d5a9 217 portraitmode = false;
WiredHome 133:e36dcfc2d756 218
WiredHome 79:544eb4964795 219 if (width >= 800 && height >= 480 && color_bpp > 8) {
WiredHome 79:544eb4964795 220 WriteCommand(0x20, 0x00); // DPCR - 1-layer mode when the resolution is too high
WiredHome 79:544eb4964795 221 } else {
WiredHome 79:544eb4964795 222 WriteCommand(0x20, 0x80); // DPCR - 2-layer mode
WiredHome 79:544eb4964795 223 }
WiredHome 79:544eb4964795 224
WiredHome 79:544eb4964795 225 // Set display image to Blue on Black as default
WiredHome 79:544eb4964795 226 window(0,0, width, height); // Initialize to full screen
WiredHome 79:544eb4964795 227 SetTextCursorControl();
WiredHome 79:544eb4964795 228 foreground(Blue);
WiredHome 79:544eb4964795 229 background(Black);
WiredHome 79:544eb4964795 230 cls(3);
WiredHome 79:544eb4964795 231
WiredHome 79:544eb4964795 232 Power(poweron);
WiredHome 131:5bd6ba2ee4a1 233 Backlight_u8(poweron);
WiredHome 81:01da2e34283d 234 if (keypadon)
WiredHome 81:01da2e34283d 235 KeypadInit();
WiredHome 124:1690a7ae871c 236 if (touchscreenon) {
WiredHome 124:1690a7ae871c 237 if (useTouchPanel == TP_NONE)
WiredHome 124:1690a7ae871c 238 useTouchPanel = TP_RES;
WiredHome 81:01da2e34283d 239 TouchPanelInit();
WiredHome 124:1690a7ae871c 240 }
WiredHome 79:544eb4964795 241 #ifdef PERF_METRICS
WiredHome 79:544eb4964795 242 performance.start();
WiredHome 79:544eb4964795 243 ClearPerformance();
WiredHome 79:544eb4964795 244 #endif
WiredHome 79:544eb4964795 245 return noerror;
WiredHome 79:544eb4964795 246 }
WiredHome 79:544eb4964795 247
WiredHome 79:544eb4964795 248
WiredHome 79:544eb4964795 249 RetCode_t RA8875::Reset(void)
WiredHome 79:544eb4964795 250 {
WiredHome 79:544eb4964795 251 RetCode_t ret;
WiredHome 79:544eb4964795 252
WiredHome 94:203729061e48 253 #if 0
WiredHome 94:203729061e48 254 if (res != (PinName)NC) {
WiredHome 94:203729061e48 255 res = 0; // Active low - assert reset
WiredHome 94:203729061e48 256 wait_ms(2); // must be > 1024 clock periods. (@25 MHz, this is 40.96 usec)
WiredHome 94:203729061e48 257 res = 1; // de-assert reset
WiredHome 94:203729061e48 258 }
WiredHome 94:203729061e48 259 #endif
WiredHome 94:203729061e48 260 ret = WriteCommand(0x01, 0x01); // Apply Display Off, Reset
WiredHome 94:203729061e48 261 wait_ms(2); // no idea if I need to wait, or how long
WiredHome 79:544eb4964795 262 if (ret == noerror) {
WiredHome 94:203729061e48 263 ret = WriteCommand(0x01, 0x00); // Display off, Remove reset
WiredHome 94:203729061e48 264 wait_ms(2); // no idea if I need to wait, or how long
WiredHome 79:544eb4964795 265 }
WiredHome 79:544eb4964795 266 return ret;
WiredHome 79:544eb4964795 267 }
WiredHome 79:544eb4964795 268
WiredHome 79:544eb4964795 269
WiredHome 79:544eb4964795 270 const char * RA8875::GetErrorMessage(RetCode_t code)
WiredHome 79:544eb4964795 271 {
WiredHome 79:544eb4964795 272 if (code >= LastErrCode)
WiredHome 79:544eb4964795 273 code = bad_parameter;
WiredHome 79:544eb4964795 274 return ErrMessages[code];
WiredHome 79:544eb4964795 275 }
WiredHome 79:544eb4964795 276
WiredHome 79:544eb4964795 277
WiredHome 61:8f3153bf0baa 278 uint16_t RA8875::GetDrawingLayer(void)
WiredHome 61:8f3153bf0baa 279 {
WiredHome 61:8f3153bf0baa 280 return (ReadCommand(0x41) & 0x01);
WiredHome 61:8f3153bf0baa 281 }
WiredHome 43:3becae133285 282
WiredHome 79:544eb4964795 283
WiredHome 50:2c4f474a2453 284 RetCode_t RA8875::SelectDrawingLayer(uint16_t layer)
WiredHome 43:3becae133285 285 {
WiredHome 43:3becae133285 286 unsigned char mwcr1 = ReadCommand(0x41) & ~0x01; // retain all but the currently selected layer
WiredHome 43:3becae133285 287
WiredHome 106:c80828f5dea4 288 if (screenwidth >= 800 && screenheight >= 480 && screenbpp > 8) {
WiredHome 43:3becae133285 289 return bad_parameter;
WiredHome 43:3becae133285 290 } else if (layer > 1) {
WiredHome 43:3becae133285 291 return bad_parameter;
WiredHome 43:3becae133285 292 } else { // layer == 0 ro 1
WiredHome 72:ecffe56af969 293 return WriteCommand(0x41, mwcr1 | layer);
WiredHome 43:3becae133285 294 }
WiredHome 43:3becae133285 295 }
WiredHome 43:3becae133285 296
WiredHome 44:207594dece70 297
WiredHome 82:f7d300f26540 298 RA8875::LayerMode_T RA8875::GetLayerMode(void)
WiredHome 82:f7d300f26540 299 {
WiredHome 82:f7d300f26540 300 return (LayerMode_T)(ReadCommand(0x52) & 0x7);
WiredHome 82:f7d300f26540 301 }
WiredHome 82:f7d300f26540 302
WiredHome 82:f7d300f26540 303
WiredHome 53:86d24b9480b9 304 RetCode_t RA8875::SetLayerMode(LayerMode_T mode)
WiredHome 44:207594dece70 305 {
WiredHome 53:86d24b9480b9 306 unsigned char ltpr0 = ReadCommand(0x52) & ~0x7; // retain all but the display layer mode
WiredHome 105:4f116006ba1f 307
WiredHome 53:86d24b9480b9 308 if (mode <= (LayerMode_T)6) {
WiredHome 53:86d24b9480b9 309 WriteCommand(0x52, ltpr0 | (mode & 0x7));
WiredHome 53:86d24b9480b9 310 return noerror;
WiredHome 53:86d24b9480b9 311 } else {
WiredHome 53:86d24b9480b9 312 return bad_parameter;
WiredHome 53:86d24b9480b9 313 }
WiredHome 44:207594dece70 314 }
WiredHome 44:207594dece70 315
WiredHome 44:207594dece70 316
WiredHome 44:207594dece70 317 RetCode_t RA8875::SetLayerTransparency(uint8_t layer1, uint8_t layer2)
WiredHome 44:207594dece70 318 {
WiredHome 44:207594dece70 319 if (layer1 > 8)
WiredHome 44:207594dece70 320 layer1 = 8;
WiredHome 44:207594dece70 321 if (layer2 > 8)
WiredHome 44:207594dece70 322 layer2 = 8;
WiredHome 44:207594dece70 323 WriteCommand(0x53, ((layer2 & 0xF) << 4) | (layer1 & 0xF));
WiredHome 44:207594dece70 324 return noerror;
WiredHome 44:207594dece70 325 }
WiredHome 44:207594dece70 326
WiredHome 44:207594dece70 327
WiredHome 53:86d24b9480b9 328 RetCode_t RA8875::SetBackgroundTransparencyColor(color_t color)
WiredHome 53:86d24b9480b9 329 {
WiredHome 133:e36dcfc2d756 330 return _writeColorTrio(0x67, color);
WiredHome 53:86d24b9480b9 331 }
WiredHome 53:86d24b9480b9 332
WiredHome 79:544eb4964795 333
WiredHome 73:f22a18707b5e 334 color_t RA8875::GetBackgroundTransparencyColor(void)
WiredHome 73:f22a18707b5e 335 {
WiredHome 73:f22a18707b5e 336 RGBQUAD q;
WiredHome 105:4f116006ba1f 337
WiredHome 73:f22a18707b5e 338 q.rgbRed = ReadCommand(0x67);
WiredHome 73:f22a18707b5e 339 q.rgbGreen = ReadCommand(0x68);
WiredHome 73:f22a18707b5e 340 q.rgbBlue = ReadCommand(0x69);
WiredHome 73:f22a18707b5e 341 return RGBQuadToRGB16(&q, 0);
WiredHome 73:f22a18707b5e 342 }
WiredHome 73:f22a18707b5e 343
WiredHome 71:dcac8efd842d 344
WiredHome 77:9206c13aa527 345 RetCode_t RA8875::KeypadInit(bool scanEnable, bool longDetect, uint8_t sampleTime, uint8_t scanFrequency,
WiredHome 77:9206c13aa527 346 uint8_t longTimeAdjustment, bool interruptEnable, bool wakeupEnable)
WiredHome 71:dcac8efd842d 347 {
WiredHome 71:dcac8efd842d 348 uint8_t value = 0;
WiredHome 77:9206c13aa527 349
WiredHome 71:dcac8efd842d 350 if (sampleTime > 3 || scanFrequency > 7 || longTimeAdjustment > 3)
WiredHome 71:dcac8efd842d 351 return bad_parameter;
WiredHome 71:dcac8efd842d 352 value |= (scanEnable) ? 0x80 : 0x00;
WiredHome 71:dcac8efd842d 353 value |= (longDetect) ? 0x40 : 0x00;
WiredHome 71:dcac8efd842d 354 value |= (sampleTime & 0x03) << 4;
WiredHome 71:dcac8efd842d 355 value |= (scanFrequency & 0x07);
WiredHome 75:ca78388cfd77 356 WriteCommand(0xC0, value); // KSCR1 - Enable Key Scan (and ignore possibility of an error)
WiredHome 77:9206c13aa527 357
WiredHome 71:dcac8efd842d 358 value = 0;
WiredHome 71:dcac8efd842d 359 value |= (wakeupEnable) ? 0x80 : 0x00;
WiredHome 71:dcac8efd842d 360 value |= (longTimeAdjustment & 0x03) << 2;
WiredHome 75:ca78388cfd77 361 WriteCommand(0xC1, value); // KSCR2 - (and ignore possibility of an error)
WiredHome 77:9206c13aa527 362
WiredHome 75:ca78388cfd77 363 value = ReadCommand(0xF0); // (and ignore possibility of an error)
WiredHome 71:dcac8efd842d 364 value &= ~0x10;
WiredHome 71:dcac8efd842d 365 value |= (interruptEnable) ? 0x10 : 0x00;
WiredHome 75:ca78388cfd77 366 return WriteCommand(0xF0, value); // INT
WiredHome 71:dcac8efd842d 367 }
WiredHome 71:dcac8efd842d 368
WiredHome 79:544eb4964795 369
WiredHome 75:ca78388cfd77 370 RetCode_t RA8875::SetKeyMap(const uint8_t * CodeList)
WiredHome 75:ca78388cfd77 371 {
WiredHome 75:ca78388cfd77 372 pKeyMap = CodeList;
WiredHome 75:ca78388cfd77 373 return noerror;
WiredHome 75:ca78388cfd77 374 }
WiredHome 75:ca78388cfd77 375
WiredHome 79:544eb4964795 376
WiredHome 75:ca78388cfd77 377 bool RA8875::readable(void)
WiredHome 71:dcac8efd842d 378 {
WiredHome 71:dcac8efd842d 379 return (ReadCommand(0xF1) & 0x10); // check KS status - true if kbhit
WiredHome 71:dcac8efd842d 380 }
WiredHome 71:dcac8efd842d 381
WiredHome 79:544eb4964795 382
WiredHome 75:ca78388cfd77 383 uint8_t RA8875::getc(void)
WiredHome 71:dcac8efd842d 384 {
WiredHome 79:544eb4964795 385 //#define GETC_DEV // for development
WiredHome 77:9206c13aa527 386 #ifdef GETC_DEV
WiredHome 75:ca78388cfd77 387 uint8_t keyCode1, keyCode2;
WiredHome 77:9206c13aa527 388 #endif
WiredHome 75:ca78388cfd77 389 uint8_t keyCode3;
WiredHome 75:ca78388cfd77 390 static uint8_t count = 0;
WiredHome 75:ca78388cfd77 391 uint8_t col, row;
WiredHome 75:ca78388cfd77 392 uint8_t key;
WiredHome 123:2f45e80fec5f 393
WiredHome 75:ca78388cfd77 394 while (!readable()) {
WiredHome 71:dcac8efd842d 395 wait_us(POLLWAITuSec);
WiredHome 75:ca78388cfd77 396 // COUNTIDLETIME(POLLWAITuSec); // As it is voluntary to call the getc and pend. Don't tally it.
WiredHome 123:2f45e80fec5f 397 if (idle_callback) {
WiredHome 123:2f45e80fec5f 398 if (external_abort == (*idle_callback)(getc_wait)) {
WiredHome 123:2f45e80fec5f 399 return 0;
WiredHome 123:2f45e80fec5f 400 }
WiredHome 123:2f45e80fec5f 401 }
WiredHome 71:dcac8efd842d 402 }
WiredHome 71:dcac8efd842d 403 // read the key press number
WiredHome 71:dcac8efd842d 404 uint8_t keyNumReg = ReadCommand(0xC1) & 0x03;
WiredHome 75:ca78388cfd77 405 count++;
WiredHome 75:ca78388cfd77 406 switch (keyNumReg) {
WiredHome 75:ca78388cfd77 407 case 0x01: // one key
WiredHome 75:ca78388cfd77 408 keyCode3 = ReadCommand(0xC2);
WiredHome 77:9206c13aa527 409 #ifdef GETC_DEV
WiredHome 75:ca78388cfd77 410 keyCode2 = 0;
WiredHome 75:ca78388cfd77 411 keyCode1 = 0;
WiredHome 77:9206c13aa527 412 #endif
WiredHome 75:ca78388cfd77 413 break;
WiredHome 75:ca78388cfd77 414 case 0x02: // two keys
WiredHome 75:ca78388cfd77 415 keyCode3 = ReadCommand(0xC3);
WiredHome 77:9206c13aa527 416 #ifdef GETC_DEV
WiredHome 75:ca78388cfd77 417 keyCode2 = ReadCommand(0xC2);
WiredHome 75:ca78388cfd77 418 keyCode1 = 0;
WiredHome 77:9206c13aa527 419 #endif
WiredHome 75:ca78388cfd77 420 break;
WiredHome 75:ca78388cfd77 421 case 0x03: // three keys
WiredHome 75:ca78388cfd77 422 keyCode3 = ReadCommand(0xC4);
WiredHome 77:9206c13aa527 423 #ifdef GETC_DEV
WiredHome 75:ca78388cfd77 424 keyCode2 = ReadCommand(0xC3);
WiredHome 75:ca78388cfd77 425 keyCode1 = ReadCommand(0xC2);
WiredHome 77:9206c13aa527 426 #endif
WiredHome 75:ca78388cfd77 427 break;
WiredHome 75:ca78388cfd77 428 default: // no keys (key released)
WiredHome 75:ca78388cfd77 429 keyCode3 = 0xFF;
WiredHome 77:9206c13aa527 430 #ifdef GETC_DEV
WiredHome 75:ca78388cfd77 431 keyCode2 = 0;
WiredHome 75:ca78388cfd77 432 keyCode1 = 0;
WiredHome 77:9206c13aa527 433 #endif
WiredHome 75:ca78388cfd77 434 break;
WiredHome 75:ca78388cfd77 435 }
WiredHome 75:ca78388cfd77 436 if (keyCode3 == 0xFF)
WiredHome 75:ca78388cfd77 437 key = pKeyMap[0]; // Key value 0
WiredHome 75:ca78388cfd77 438 else {
WiredHome 75:ca78388cfd77 439 row = (keyCode3 >> 4) & 0x03;
WiredHome 75:ca78388cfd77 440 col = (keyCode3 & 7);
WiredHome 75:ca78388cfd77 441 key = row * 5 + col + 1; // Keys value 1 - 20
WiredHome 75:ca78388cfd77 442 if (key > 21) {
WiredHome 75:ca78388cfd77 443 key = 21;
WiredHome 75:ca78388cfd77 444 }
WiredHome 75:ca78388cfd77 445 key = pKeyMap[key];
WiredHome 75:ca78388cfd77 446 key |= (keyCode3 & 0x80); // combine the key held flag
WiredHome 75:ca78388cfd77 447 }
WiredHome 77:9206c13aa527 448 #if GETC_DEV // for Development only
WiredHome 75:ca78388cfd77 449 SetTextCursor(0, 20);
WiredHome 75:ca78388cfd77 450 printf(" Reg: %02x\r\n", keyNumReg);
WiredHome 75:ca78388cfd77 451 printf(" key1: %02x\r\n", keyCode1);
WiredHome 75:ca78388cfd77 452 printf(" key2: %02x\r\n", keyCode2);
WiredHome 75:ca78388cfd77 453 printf(" key3: %02x\r\n", keyCode3);
WiredHome 75:ca78388cfd77 454 printf(" count: %02X\r\n", count);
WiredHome 75:ca78388cfd77 455 printf(" key: %02X\r\n", key);
WiredHome 77:9206c13aa527 456 #endif
WiredHome 75:ca78388cfd77 457 WriteCommand(0xF1, 0x10); // Clear KS status
WiredHome 75:ca78388cfd77 458 return key;
WiredHome 71:dcac8efd842d 459 }
WiredHome 71:dcac8efd842d 460
WiredHome 79:544eb4964795 461
WiredHome 19:3f82c1161fd2 462 #ifdef PERF_METRICS
WiredHome 19:3f82c1161fd2 463 void RA8875::ClearPerformance()
WiredHome 19:3f82c1161fd2 464 {
WiredHome 100:0b084475d5a9 465 int i;
WiredHome 100:0b084475d5a9 466
WiredHome 100:0b084475d5a9 467 for (i=0; i<METRICCOUNT; i++)
WiredHome 19:3f82c1161fd2 468 metrics[i] = 0;
WiredHome 75:ca78388cfd77 469 idletime_usec = 0;
WiredHome 100:0b084475d5a9 470 for (i=0; i<256; i++)
WiredHome 100:0b084475d5a9 471 commandsUsed[i] = 0;
WiredHome 19:3f82c1161fd2 472 }
WiredHome 19:3f82c1161fd2 473
WiredHome 79:544eb4964795 474
WiredHome 19:3f82c1161fd2 475 void RA8875::RegisterPerformance(method_e method)
WiredHome 19:3f82c1161fd2 476 {
WiredHome 19:3f82c1161fd2 477 unsigned long elapsed = performance.read_us();
WiredHome 73:f22a18707b5e 478
WiredHome 19:3f82c1161fd2 479 if (method < METRICCOUNT && elapsed > metrics[method])
WiredHome 19:3f82c1161fd2 480 metrics[method] = elapsed;
WiredHome 19:3f82c1161fd2 481 }
WiredHome 19:3f82c1161fd2 482
WiredHome 79:544eb4964795 483
WiredHome 66:468a11f05580 484 void RA8875::CountIdleTime(uint32_t t)
WiredHome 66:468a11f05580 485 {
WiredHome 75:ca78388cfd77 486 idletime_usec += t;
WiredHome 66:468a11f05580 487 }
WiredHome 44:207594dece70 488
WiredHome 79:544eb4964795 489
WiredHome 41:2956a0a221e5 490 void RA8875::ReportPerformance(Serial & pc)
WiredHome 19:3f82c1161fd2 491 {
WiredHome 100:0b084475d5a9 492 int i;
WiredHome 100:0b084475d5a9 493
WiredHome 41:2956a0a221e5 494 pc.printf("\r\nPerformance Metrics\r\n");
WiredHome 100:0b084475d5a9 495 for (i=0; i<METRICCOUNT; i++) {
WiredHome 41:2956a0a221e5 496 pc.printf("%10d uS %s\r\n", metrics[i], metricsName[i]);
WiredHome 66:468a11f05580 497 }
WiredHome 75:ca78388cfd77 498 pc.printf("%10d uS Idle time polling display for ready.\r\n", idletime_usec);
WiredHome 91:ca5f829e6d27 499 for (i=0; i<256; i++) {
WiredHome 91:ca5f829e6d27 500 if (commandsUsed[i])
WiredHome 100:0b084475d5a9 501 pc.printf("Command %02X used %5d times.\r\n", i, commandsUsed[i]);
WiredHome 91:ca5f829e6d27 502 }
WiredHome 19:3f82c1161fd2 503 }
WiredHome 19:3f82c1161fd2 504 #endif
WiredHome 19:3f82c1161fd2 505
WiredHome 44:207594dece70 506
WiredHome 82:f7d300f26540 507 bool RA8875::Intersect(rect_t rect, point_t p)
WiredHome 82:f7d300f26540 508 {
WiredHome 82:f7d300f26540 509 if (p.x >= min(rect.p1.x, rect.p2.x) && p.x <= max(rect.p1.x, rect.p2.x)
WiredHome 82:f7d300f26540 510 && p.y >= min(rect.p1.y, rect.p2.y) && p.y <= max(rect.p1.y, rect.p2.y))
WiredHome 82:f7d300f26540 511 return true;
WiredHome 82:f7d300f26540 512 else
WiredHome 82:f7d300f26540 513 return false;
WiredHome 82:f7d300f26540 514 }
WiredHome 82:f7d300f26540 515
WiredHome 82:f7d300f26540 516
WiredHome 131:5bd6ba2ee4a1 517 bool RA8875::Intersect(rect_t rect1, rect_t rect2)
WiredHome 131:5bd6ba2ee4a1 518 {
WiredHome 131:5bd6ba2ee4a1 519 point_t bl, tr;
WiredHome 131:5bd6ba2ee4a1 520
WiredHome 131:5bd6ba2ee4a1 521 bl.x = rect2.p1.x;
WiredHome 131:5bd6ba2ee4a1 522 bl.y = rect2.p2.y;
WiredHome 131:5bd6ba2ee4a1 523 tr.x = rect2.p2.x;
WiredHome 131:5bd6ba2ee4a1 524 tr.y = rect2.p1.y;
WiredHome 131:5bd6ba2ee4a1 525 if (Intersect(rect1, rect2.p1) || Intersect(rect1, rect2.p2)
WiredHome 131:5bd6ba2ee4a1 526 || Intersect(rect1, bl) || Intersect(rect1, tr))
WiredHome 131:5bd6ba2ee4a1 527 return true;
WiredHome 131:5bd6ba2ee4a1 528 else
WiredHome 131:5bd6ba2ee4a1 529 return false;
WiredHome 131:5bd6ba2ee4a1 530 }
WiredHome 131:5bd6ba2ee4a1 531
WiredHome 131:5bd6ba2ee4a1 532
WiredHome 82:f7d300f26540 533
WiredHome 38:38d503b4fad6 534 RetCode_t RA8875::WriteCommandW(uint8_t command, uint16_t data)
WiredHome 38:38d503b4fad6 535 {
WiredHome 38:38d503b4fad6 536 WriteCommand(command, data & 0xFF);
WiredHome 38:38d503b4fad6 537 WriteCommand(command+1, data >> 8);
WiredHome 38:38d503b4fad6 538 return noerror;
WiredHome 38:38d503b4fad6 539 }
WiredHome 38:38d503b4fad6 540
WiredHome 44:207594dece70 541
WiredHome 19:3f82c1161fd2 542 RetCode_t RA8875::WriteCommand(unsigned char command, unsigned int data)
WiredHome 19:3f82c1161fd2 543 {
WiredHome 91:ca5f829e6d27 544 #ifdef PERF_METRICS
WiredHome 92:ce1ab76e8614 545 if (commandsUsed[command] < 65535)
WiredHome 91:ca5f829e6d27 546 commandsUsed[command]++;
WiredHome 91:ca5f829e6d27 547 #endif
WiredHome 79:544eb4964795 548 _select(true);
WiredHome 83:7bad0068cca0 549 _spiwrite(0x80); // RS:1 (Cmd/Status), RW:0 (Write)
WiredHome 79:544eb4964795 550 _spiwrite(command);
WiredHome 19:3f82c1161fd2 551 if (data <= 0xFF) { // only if in the valid range
WiredHome 79:544eb4964795 552 _spiwrite(0x00);
WiredHome 79:544eb4964795 553 _spiwrite(data);
WiredHome 19:3f82c1161fd2 554 }
WiredHome 79:544eb4964795 555 _select(false);
WiredHome 19:3f82c1161fd2 556 return noerror;
WiredHome 19:3f82c1161fd2 557 }
WiredHome 19:3f82c1161fd2 558
WiredHome 44:207594dece70 559
WiredHome 38:38d503b4fad6 560 RetCode_t RA8875::WriteDataW(uint16_t data)
WiredHome 38:38d503b4fad6 561 {
WiredHome 79:544eb4964795 562 _select(true);
WiredHome 83:7bad0068cca0 563 _spiwrite(0x00); // RS:0 (Data), RW:0 (Write)
WiredHome 79:544eb4964795 564 _spiwrite(data & 0xFF);
WiredHome 79:544eb4964795 565 _spiwrite(data >> 8);
WiredHome 79:544eb4964795 566 _select(false);
WiredHome 38:38d503b4fad6 567 return noerror;
WiredHome 38:38d503b4fad6 568 }
WiredHome 38:38d503b4fad6 569
WiredHome 44:207594dece70 570
WiredHome 19:3f82c1161fd2 571 RetCode_t RA8875::WriteData(unsigned char data)
WiredHome 19:3f82c1161fd2 572 {
WiredHome 79:544eb4964795 573 _select(true);
WiredHome 83:7bad0068cca0 574 _spiwrite(0x00); // RS:0 (Data), RW:0 (Write)
WiredHome 79:544eb4964795 575 _spiwrite(data);
WiredHome 79:544eb4964795 576 _select(false);
WiredHome 19:3f82c1161fd2 577 return noerror;
WiredHome 19:3f82c1161fd2 578 }
WiredHome 19:3f82c1161fd2 579
WiredHome 44:207594dece70 580
WiredHome 19:3f82c1161fd2 581 unsigned char RA8875::ReadCommand(unsigned char command)
WiredHome 19:3f82c1161fd2 582 {
WiredHome 19:3f82c1161fd2 583 WriteCommand(command);
WiredHome 19:3f82c1161fd2 584 return ReadData();
WiredHome 19:3f82c1161fd2 585 }
WiredHome 19:3f82c1161fd2 586
WiredHome 44:207594dece70 587
WiredHome 19:3f82c1161fd2 588 unsigned char RA8875::ReadData(void)
WiredHome 19:3f82c1161fd2 589 {
WiredHome 19:3f82c1161fd2 590 unsigned char data;
WiredHome 73:f22a18707b5e 591
WiredHome 79:544eb4964795 592 _select(true);
WiredHome 83:7bad0068cca0 593 _spiwrite(0x40); // RS:0 (Data), RW:1 (Read)
WiredHome 79:544eb4964795 594 data = _spiread();
WiredHome 79:544eb4964795 595 _select(false);
WiredHome 19:3f82c1161fd2 596 return data;
WiredHome 19:3f82c1161fd2 597 }
WiredHome 19:3f82c1161fd2 598
WiredHome 44:207594dece70 599
WiredHome 41:2956a0a221e5 600 uint16_t RA8875::ReadDataW(void)
WiredHome 41:2956a0a221e5 601 {
WiredHome 41:2956a0a221e5 602 uint16_t data;
WiredHome 73:f22a18707b5e 603
WiredHome 79:544eb4964795 604 _select(true);
WiredHome 83:7bad0068cca0 605 _spiwrite(0x40); // RS:0 (Data), RW:1 (Read)
WiredHome 79:544eb4964795 606 data = _spiread();
WiredHome 79:544eb4964795 607 data |= (_spiread() << 8);
WiredHome 79:544eb4964795 608 _select(false);
WiredHome 41:2956a0a221e5 609 return data;
WiredHome 41:2956a0a221e5 610 }
WiredHome 41:2956a0a221e5 611
WiredHome 44:207594dece70 612
WiredHome 19:3f82c1161fd2 613 unsigned char RA8875::ReadStatus(void)
WiredHome 19:3f82c1161fd2 614 {
WiredHome 19:3f82c1161fd2 615 unsigned char data;
WiredHome 73:f22a18707b5e 616
WiredHome 79:544eb4964795 617 _select(true);
WiredHome 83:7bad0068cca0 618 _spiwrite(0xC0); // RS:1 (Cmd/Status), RW:1 (Read) (Read STSR)
WiredHome 79:544eb4964795 619 data = _spiread();
WiredHome 79:544eb4964795 620 _select(false);
WiredHome 19:3f82c1161fd2 621 return data;
WiredHome 19:3f82c1161fd2 622 }
WiredHome 19:3f82c1161fd2 623
WiredHome 79:544eb4964795 624
WiredHome 66:468a11f05580 625 /// @todo add a timeout and return false, but how long
WiredHome 66:468a11f05580 626 /// to wait since some operations can be very long.
WiredHome 66:468a11f05580 627 bool RA8875::_WaitWhileBusy(uint8_t mask)
WiredHome 66:468a11f05580 628 {
WiredHome 66:468a11f05580 629 int i = 20000/POLLWAITuSec; // 20 msec max
WiredHome 66:468a11f05580 630
WiredHome 67:9f834f0ff97d 631 while (i-- && ReadStatus() & mask) {
WiredHome 66:468a11f05580 632 wait_us(POLLWAITuSec);
WiredHome 68:ab08efabfc88 633 COUNTIDLETIME(POLLWAITuSec);
WiredHome 123:2f45e80fec5f 634 if (idle_callback) {
WiredHome 123:2f45e80fec5f 635 if (external_abort == (*idle_callback)(status_wait)) {
WiredHome 123:2f45e80fec5f 636 return false;
WiredHome 123:2f45e80fec5f 637 }
WiredHome 123:2f45e80fec5f 638 }
WiredHome 67:9f834f0ff97d 639 }
WiredHome 66:468a11f05580 640 if (i)
WiredHome 66:468a11f05580 641 return true;
WiredHome 66:468a11f05580 642 else
WiredHome 66:468a11f05580 643 return false;
WiredHome 66:468a11f05580 644 }
WiredHome 66:468a11f05580 645
WiredHome 79:544eb4964795 646
WiredHome 66:468a11f05580 647 /// @todo add a timeout and return false, but how long
WiredHome 66:468a11f05580 648 /// to wait since some operations can be very long.
WiredHome 66:468a11f05580 649 bool RA8875::_WaitWhileReg(uint8_t reg, uint8_t mask)
WiredHome 66:468a11f05580 650 {
WiredHome 66:468a11f05580 651 int i = 20000/POLLWAITuSec; // 20 msec max
WiredHome 66:468a11f05580 652
WiredHome 67:9f834f0ff97d 653 while (i-- && ReadCommand(reg) & mask) {
WiredHome 66:468a11f05580 654 wait_us(POLLWAITuSec);
WiredHome 68:ab08efabfc88 655 COUNTIDLETIME(POLLWAITuSec);
WiredHome 123:2f45e80fec5f 656 if (idle_callback) {
WiredHome 123:2f45e80fec5f 657 if (external_abort == (*idle_callback)(command_wait)) {
WiredHome 123:2f45e80fec5f 658 return false;
WiredHome 123:2f45e80fec5f 659 }
WiredHome 123:2f45e80fec5f 660 }
WiredHome 67:9f834f0ff97d 661 }
WiredHome 66:468a11f05580 662 if (i)
WiredHome 66:468a11f05580 663 return true;
WiredHome 66:468a11f05580 664 else
WiredHome 66:468a11f05580 665 return false;
WiredHome 66:468a11f05580 666 }
WiredHome 66:468a11f05580 667
WiredHome 106:c80828f5dea4 668 // RRRR RGGG GGGB BBBB
WiredHome 106:c80828f5dea4 669 // 4321 0543 2104 3210
WiredHome 106:c80828f5dea4 670 // RRRG GGBB
WiredHome 106:c80828f5dea4 671 // 2102 1010
WiredHome 105:4f116006ba1f 672 uint8_t RA8875::_cvt16to8(color_t c16)
WiredHome 105:4f116006ba1f 673 {
WiredHome 105:4f116006ba1f 674 return ((c16 >> 8) & 0xE0)
WiredHome 105:4f116006ba1f 675 | ((c16 >> 6) & 0x1C)
WiredHome 105:4f116006ba1f 676 | ((c16 >> 3) & 0x03);
WiredHome 105:4f116006ba1f 677 }
WiredHome 105:4f116006ba1f 678
WiredHome 106:c80828f5dea4 679 // RRRG GGBB
WiredHome 106:c80828f5dea4 680 // 2102 1010
WiredHome 106:c80828f5dea4 681 // RRRR RGGG GGGB BBBB
WiredHome 106:c80828f5dea4 682 // 2101 0543 2104 3210
WiredHome 105:4f116006ba1f 683 color_t RA8875::_cvt8to16(uint8_t c8)
WiredHome 105:4f116006ba1f 684 {
WiredHome 106:c80828f5dea4 685 color_t c16;
WiredHome 106:c80828f5dea4 686 color_t temp = (color_t)c8;
WiredHome 106:c80828f5dea4 687
WiredHome 106:c80828f5dea4 688 c16 = ((temp & 0xE0) << 8)
WiredHome 106:c80828f5dea4 689 | ((temp & 0xC0) << 5)
WiredHome 106:c80828f5dea4 690 | ((temp & 0x1C) << 6)
WiredHome 106:c80828f5dea4 691 | ((temp & 0x1C) << 3)
WiredHome 106:c80828f5dea4 692 | ((temp & 0x03) << 3)
WiredHome 106:c80828f5dea4 693 | ((temp & 0x03) << 1)
WiredHome 106:c80828f5dea4 694 | ((temp & 0x03) >> 1);
WiredHome 106:c80828f5dea4 695 c16 = (c16 << 8) | (c16 >> 8);
WiredHome 105:4f116006ba1f 696 return c16;
WiredHome 105:4f116006ba1f 697 }
WiredHome 66:468a11f05580 698
WiredHome 133:e36dcfc2d756 699 RetCode_t RA8875::_writeColorTrio(uint8_t regAddr, color_t color)
WiredHome 133:e36dcfc2d756 700 {
WiredHome 133:e36dcfc2d756 701 RetCode_t rt = noerror;
WiredHome 133:e36dcfc2d756 702
WiredHome 133:e36dcfc2d756 703 if (screenbpp == 16) {
WiredHome 133:e36dcfc2d756 704 WriteCommand(regAddr+0, (color>>11)); // BGCR0
WiredHome 133:e36dcfc2d756 705 WriteCommand(regAddr+1, (unsigned char)(color>>5)); // BGCR1
WiredHome 133:e36dcfc2d756 706 rt = WriteCommand(regAddr+2, (unsigned char)(color)); // BGCR2
WiredHome 133:e36dcfc2d756 707 } else {
WiredHome 133:e36dcfc2d756 708 uint8_t r, g, b;
WiredHome 133:e36dcfc2d756 709
WiredHome 133:e36dcfc2d756 710 // RRRR RGGG GGGB BBBB RGB
WiredHome 133:e36dcfc2d756 711 // RRR GGG B B
WiredHome 133:e36dcfc2d756 712 r = (uint8_t)((color) >> 13);
WiredHome 133:e36dcfc2d756 713 g = (uint8_t)((color) >> 8);
WiredHome 133:e36dcfc2d756 714 b = (uint8_t)((color) >> 3);
WiredHome 133:e36dcfc2d756 715 WriteCommand(regAddr+0, r); // BGCR0
WiredHome 133:e36dcfc2d756 716 WriteCommand(regAddr+1, g); // BGCR1
WiredHome 133:e36dcfc2d756 717 rt = WriteCommand(regAddr+2, b); // BGCR2
WiredHome 133:e36dcfc2d756 718 }
WiredHome 133:e36dcfc2d756 719 return rt;
WiredHome 133:e36dcfc2d756 720 }
WiredHome 133:e36dcfc2d756 721
WiredHome 133:e36dcfc2d756 722 color_t RA8875::_readColorTrio(uint8_t regAddr)
WiredHome 133:e36dcfc2d756 723 {
WiredHome 133:e36dcfc2d756 724 color_t color;
WiredHome 133:e36dcfc2d756 725 uint8_t r, g, b;
WiredHome 133:e36dcfc2d756 726
WiredHome 133:e36dcfc2d756 727 r = ReadCommand(regAddr+0);
WiredHome 133:e36dcfc2d756 728 g = ReadCommand(regAddr+1);
WiredHome 133:e36dcfc2d756 729 b = ReadCommand(regAddr+2);
WiredHome 133:e36dcfc2d756 730 if (screenbpp == 16) {
WiredHome 133:e36dcfc2d756 731 // 000R RRRR 00GG GGGG 000B BBBB
WiredHome 133:e36dcfc2d756 732 // RRRR RGGG GGGB BBBB
WiredHome 133:e36dcfc2d756 733 color = (r & 0x1F) << 11;
WiredHome 133:e36dcfc2d756 734 color |= (g & 0x3F) << 5;
WiredHome 133:e36dcfc2d756 735 color |= (b & 0x1F);
WiredHome 133:e36dcfc2d756 736 } else {
WiredHome 133:e36dcfc2d756 737 // RRRG GGBB
WiredHome 133:e36dcfc2d756 738 // RRRR RGGG GGGB BBBB
WiredHome 133:e36dcfc2d756 739 color = (r & 0x07) << 13;
WiredHome 133:e36dcfc2d756 740 color |= (g & 0x07) << 8;
WiredHome 133:e36dcfc2d756 741 color |= (b & 0x03) << 3;
WiredHome 133:e36dcfc2d756 742 }
WiredHome 133:e36dcfc2d756 743 return color;
WiredHome 133:e36dcfc2d756 744 }
WiredHome 133:e36dcfc2d756 745
WiredHome 133:e36dcfc2d756 746
WiredHome 37:f19b7e7449dc 747 dim_t RA8875::fontwidth(void)
WiredHome 19:3f82c1161fd2 748 {
WiredHome 19:3f82c1161fd2 749 if (font == NULL)
WiredHome 55:dfbabef7003e 750 return (((ReadCommand(0x22) >> 2) & 0x3) + 1) * 8;
WiredHome 19:3f82c1161fd2 751 else
WiredHome 98:ecebed9b80b2 752 return extFontWidth;
WiredHome 19:3f82c1161fd2 753 }
WiredHome 19:3f82c1161fd2 754
WiredHome 44:207594dece70 755
WiredHome 37:f19b7e7449dc 756 dim_t RA8875::fontheight(void)
WiredHome 19:3f82c1161fd2 757 {
WiredHome 19:3f82c1161fd2 758 if (font == NULL)
WiredHome 23:a50ded45dbaf 759 return (((ReadCommand(0x22) >> 0) & 0x3) + 1) * 16;
WiredHome 19:3f82c1161fd2 760 else
WiredHome 98:ecebed9b80b2 761 return extFontHeight;
WiredHome 19:3f82c1161fd2 762 }
WiredHome 19:3f82c1161fd2 763
WiredHome 44:207594dece70 764
WiredHome 37:f19b7e7449dc 765 RetCode_t RA8875::locate(textloc_t column, textloc_t row)
WiredHome 19:3f82c1161fd2 766 {
WiredHome 32:0e4f2ae512e2 767 return SetTextCursor(column * fontwidth(), row * fontheight());
WiredHome 19:3f82c1161fd2 768 }
WiredHome 19:3f82c1161fd2 769
WiredHome 44:207594dece70 770
WiredHome 19:3f82c1161fd2 771 int RA8875::columns(void)
WiredHome 19:3f82c1161fd2 772 {
WiredHome 105:4f116006ba1f 773 return screenwidth / fontwidth();
WiredHome 19:3f82c1161fd2 774 }
WiredHome 19:3f82c1161fd2 775
WiredHome 44:207594dece70 776
WiredHome 19:3f82c1161fd2 777 int RA8875::rows(void)
WiredHome 19:3f82c1161fd2 778 {
WiredHome 105:4f116006ba1f 779 return screenheight / fontheight();
WiredHome 19:3f82c1161fd2 780 }
WiredHome 19:3f82c1161fd2 781
WiredHome 44:207594dece70 782
WiredHome 38:38d503b4fad6 783 dim_t RA8875::width(void)
WiredHome 19:3f82c1161fd2 784 {
WiredHome 90:d113d71ae4f0 785 if (portraitmode)
WiredHome 90:d113d71ae4f0 786 return screenheight;
WiredHome 90:d113d71ae4f0 787 else
WiredHome 90:d113d71ae4f0 788 return screenwidth;
WiredHome 19:3f82c1161fd2 789 }
WiredHome 19:3f82c1161fd2 790
WiredHome 44:207594dece70 791
WiredHome 38:38d503b4fad6 792 dim_t RA8875::height(void)
WiredHome 19:3f82c1161fd2 793 {
WiredHome 90:d113d71ae4f0 794 if (portraitmode)
WiredHome 90:d113d71ae4f0 795 return screenwidth;
WiredHome 90:d113d71ae4f0 796 else
WiredHome 90:d113d71ae4f0 797 return screenheight;
WiredHome 19:3f82c1161fd2 798 }
WiredHome 19:3f82c1161fd2 799
WiredHome 44:207594dece70 800
WiredHome 43:3becae133285 801 dim_t RA8875::color_bpp(void)
WiredHome 43:3becae133285 802 {
WiredHome 105:4f116006ba1f 803 return screenbpp;
WiredHome 43:3becae133285 804 }
WiredHome 43:3becae133285 805
WiredHome 103:7e0464ca6c5c 806 RetCode_t RA8875::SetTextCursor(point_t p)
WiredHome 103:7e0464ca6c5c 807 {
WiredHome 103:7e0464ca6c5c 808 return SetTextCursor(p.x, p.y);
WiredHome 103:7e0464ca6c5c 809 }
WiredHome 44:207594dece70 810
WiredHome 37:f19b7e7449dc 811 RetCode_t RA8875::SetTextCursor(loc_t x, loc_t y)
WiredHome 19:3f82c1161fd2 812 {
WiredHome 98:ecebed9b80b2 813 INFO("SetTextCursor(%d, %d)", x, y);
WiredHome 75:ca78388cfd77 814 cursor_x = x; // set these values for non-internal fonts
WiredHome 75:ca78388cfd77 815 cursor_y = y;
WiredHome 38:38d503b4fad6 816 WriteCommandW(0x2A, x);
WiredHome 38:38d503b4fad6 817 WriteCommandW(0x2C, y);
WiredHome 19:3f82c1161fd2 818 return noerror;
WiredHome 19:3f82c1161fd2 819 }
WiredHome 19:3f82c1161fd2 820
WiredHome 103:7e0464ca6c5c 821 point_t RA8875::GetTextCursor(void)
WiredHome 103:7e0464ca6c5c 822 {
WiredHome 103:7e0464ca6c5c 823 point_t p;
WiredHome 103:7e0464ca6c5c 824
WiredHome 103:7e0464ca6c5c 825 p.x = GetTextCursor_X();
WiredHome 103:7e0464ca6c5c 826 p.y = GetTextCursor_Y();
WiredHome 103:7e0464ca6c5c 827 return p;
WiredHome 103:7e0464ca6c5c 828 }
WiredHome 44:207594dece70 829
WiredHome 37:f19b7e7449dc 830 loc_t RA8875::GetTextCursor_Y(void)
WiredHome 29:422616aa04bd 831 {
WiredHome 98:ecebed9b80b2 832 loc_t y;
WiredHome 98:ecebed9b80b2 833
WiredHome 29:422616aa04bd 834 if (font == NULL)
WiredHome 98:ecebed9b80b2 835 y = ReadCommand(0x2C) | (ReadCommand(0x2D) << 8);
WiredHome 29:422616aa04bd 836 else
WiredHome 98:ecebed9b80b2 837 y = cursor_y;
WiredHome 98:ecebed9b80b2 838 INFO("GetTextCursor_Y = %d", y);
WiredHome 98:ecebed9b80b2 839 return y;
WiredHome 29:422616aa04bd 840 }
WiredHome 29:422616aa04bd 841
WiredHome 44:207594dece70 842
WiredHome 37:f19b7e7449dc 843 loc_t RA8875::GetTextCursor_X(void)
WiredHome 29:422616aa04bd 844 {
WiredHome 98:ecebed9b80b2 845 loc_t x;
WiredHome 98:ecebed9b80b2 846
WiredHome 29:422616aa04bd 847 if (font == NULL)
WiredHome 98:ecebed9b80b2 848 x = ReadCommand(0x2A) | (ReadCommand(0x2B) << 8);
WiredHome 29:422616aa04bd 849 else
WiredHome 98:ecebed9b80b2 850 x = cursor_x;
WiredHome 98:ecebed9b80b2 851 INFO("GetTextCursor_X = %d", x);
WiredHome 98:ecebed9b80b2 852 return x;
WiredHome 29:422616aa04bd 853 }
WiredHome 29:422616aa04bd 854
WiredHome 44:207594dece70 855
WiredHome 24:8ca861acf12d 856 RetCode_t RA8875::SetTextCursorControl(cursor_t cursor, bool blink)
WiredHome 23:a50ded45dbaf 857 {
WiredHome 23:a50ded45dbaf 858 unsigned char mwcr0 = ReadCommand(0x40) & 0x0F; // retain direction, auto-increase
WiredHome 43:3becae133285 859 unsigned char mwcr1 = ReadCommand(0x41) & 0x01; // retain currently selected layer
WiredHome 24:8ca861acf12d 860 unsigned char horz = 0;
WiredHome 24:8ca861acf12d 861 unsigned char vert = 0;
WiredHome 73:f22a18707b5e 862
WiredHome 24:8ca861acf12d 863 mwcr0 |= 0x80; // text mode
WiredHome 24:8ca861acf12d 864 if (cursor != NOCURSOR)
WiredHome 24:8ca861acf12d 865 mwcr0 |= 0x40; // visible
WiredHome 23:a50ded45dbaf 866 if (blink)
WiredHome 24:8ca861acf12d 867 mwcr0 |= 0x20; // blink
WiredHome 23:a50ded45dbaf 868 WriteCommand(0x40, mwcr0); // configure the cursor
WiredHome 43:3becae133285 869 WriteCommand(0x41, mwcr1); // close the graphics cursor
WiredHome 24:8ca861acf12d 870 WriteCommand(0x44, 0x1f); // The cursor flashing cycle
WiredHome 24:8ca861acf12d 871 switch (cursor) {
WiredHome 24:8ca861acf12d 872 case IBEAM:
WiredHome 24:8ca861acf12d 873 horz = 0x01;
WiredHome 24:8ca861acf12d 874 vert = 0x1F;
WiredHome 24:8ca861acf12d 875 break;
WiredHome 24:8ca861acf12d 876 case UNDER:
WiredHome 24:8ca861acf12d 877 horz = 0x07;
WiredHome 24:8ca861acf12d 878 vert = 0x01;
WiredHome 24:8ca861acf12d 879 break;
WiredHome 24:8ca861acf12d 880 case BLOCK:
WiredHome 24:8ca861acf12d 881 horz = 0x07;
WiredHome 24:8ca861acf12d 882 vert = 0x1F;
WiredHome 24:8ca861acf12d 883 break;
WiredHome 24:8ca861acf12d 884 case NOCURSOR:
WiredHome 24:8ca861acf12d 885 default:
WiredHome 24:8ca861acf12d 886 break;
WiredHome 24:8ca861acf12d 887 }
WiredHome 24:8ca861acf12d 888 WriteCommand(0x4e, horz); // The cursor size horz
WiredHome 24:8ca861acf12d 889 WriteCommand(0x4f, vert); // The cursor size vert
WiredHome 23:a50ded45dbaf 890 return noerror;
WiredHome 23:a50ded45dbaf 891 }
WiredHome 23:a50ded45dbaf 892
WiredHome 44:207594dece70 893
WiredHome 19:3f82c1161fd2 894 RetCode_t RA8875::SetTextFont(RA8875::font_t font)
WiredHome 19:3f82c1161fd2 895 {
WiredHome 19:3f82c1161fd2 896 if (/*font >= RA8875::ISO8859_1 && */ font <= RA8875::ISO8859_4) {
WiredHome 19:3f82c1161fd2 897 WriteCommand(0x21, (unsigned int)(font));
WiredHome 19:3f82c1161fd2 898 return noerror;
WiredHome 19:3f82c1161fd2 899 } else {
WiredHome 19:3f82c1161fd2 900 return bad_parameter;
WiredHome 19:3f82c1161fd2 901 }
WiredHome 19:3f82c1161fd2 902 }
WiredHome 19:3f82c1161fd2 903
WiredHome 44:207594dece70 904
WiredHome 84:e102021864b5 905 RetCode_t RA8875::SetOrientation(RA8875::orientation_t angle)
WiredHome 84:e102021864b5 906 {
WiredHome 84:e102021864b5 907 uint8_t fncr1Val = ReadCommand(0x22);
WiredHome 84:e102021864b5 908 uint8_t dpcrVal = ReadCommand(0x20);
WiredHome 84:e102021864b5 909
WiredHome 84:e102021864b5 910 fncr1Val &= ~0x10; // remove the old direction bit
WiredHome 84:e102021864b5 911 dpcrVal &= ~0x0C; // remove the old scan direction bits
WiredHome 84:e102021864b5 912 switch (angle) {
WiredHome 84:e102021864b5 913 case RA8875::normal:
WiredHome 84:e102021864b5 914 //fncr1Val |= 0x10;
WiredHome 84:e102021864b5 915 //dpcrVal |= 0x00;
WiredHome 90:d113d71ae4f0 916 portraitmode = false;
WiredHome 84:e102021864b5 917 break;
WiredHome 84:e102021864b5 918 case RA8875::rotate_90:
WiredHome 84:e102021864b5 919 fncr1Val |= 0x10;
WiredHome 84:e102021864b5 920 dpcrVal |= 0x08;
WiredHome 90:d113d71ae4f0 921 portraitmode = true;
WiredHome 84:e102021864b5 922 break;
WiredHome 84:e102021864b5 923 case RA8875::rotate_180:
WiredHome 84:e102021864b5 924 //fncr1Val |= 0x00;
WiredHome 84:e102021864b5 925 dpcrVal |= 0x0C;
WiredHome 90:d113d71ae4f0 926 portraitmode = false;
WiredHome 84:e102021864b5 927 break;
WiredHome 84:e102021864b5 928 case RA8875::rotate_270:
WiredHome 84:e102021864b5 929 fncr1Val |= 0x10;
WiredHome 84:e102021864b5 930 dpcrVal |= 0x04;
WiredHome 90:d113d71ae4f0 931 portraitmode = true;
WiredHome 84:e102021864b5 932 break;
WiredHome 84:e102021864b5 933 default:
WiredHome 84:e102021864b5 934 return bad_parameter;
WiredHome 84:e102021864b5 935 }
WiredHome 100:0b084475d5a9 936 INFO("Orientation: %d, %d", angle, portraitmode);
WiredHome 84:e102021864b5 937 WriteCommand(0x22, fncr1Val);
WiredHome 84:e102021864b5 938 return WriteCommand(0x20, dpcrVal);
WiredHome 84:e102021864b5 939 }
WiredHome 84:e102021864b5 940
WiredHome 84:e102021864b5 941
WiredHome 19:3f82c1161fd2 942 RetCode_t RA8875::SetTextFontControl(fill_t fillit,
WiredHome 73:f22a18707b5e 943 RA8875::HorizontalScale hScale,
WiredHome 73:f22a18707b5e 944 RA8875::VerticalScale vScale,
WiredHome 73:f22a18707b5e 945 RA8875::alignment_t alignment)
WiredHome 19:3f82c1161fd2 946 {
WiredHome 73:f22a18707b5e 947 if (hScale >= 1 && hScale <= 4 &&
WiredHome 73:f22a18707b5e 948 vScale >= 1 && vScale <= 4) {
WiredHome 84:e102021864b5 949 uint8_t fncr1Val = ReadCommand(0x22);
WiredHome 84:e102021864b5 950
WiredHome 98:ecebed9b80b2 951 fncr1Val &= ~0x10; // do not disturb the rotate flag
WiredHome 19:3f82c1161fd2 952 if (alignment == align_full)
WiredHome 84:e102021864b5 953 fncr1Val |= 0x80;
WiredHome 19:3f82c1161fd2 954 if (fillit == NOFILL)
WiredHome 84:e102021864b5 955 fncr1Val |= 0x40;
WiredHome 84:e102021864b5 956 fncr1Val |= ((hScale - 1) << 2);
WiredHome 84:e102021864b5 957 fncr1Val |= ((vScale - 1) << 0);
WiredHome 84:e102021864b5 958 return WriteCommand(0x22, fncr1Val);
WiredHome 19:3f82c1161fd2 959 } else {
WiredHome 19:3f82c1161fd2 960 return bad_parameter;
WiredHome 19:3f82c1161fd2 961 }
WiredHome 19:3f82c1161fd2 962 }
WiredHome 19:3f82c1161fd2 963
WiredHome 44:207594dece70 964
WiredHome 19:3f82c1161fd2 965 RetCode_t RA8875::SetTextFontSize(RA8875::HorizontalScale hScale, RA8875::VerticalScale vScale)
WiredHome 19:3f82c1161fd2 966 {
WiredHome 19:3f82c1161fd2 967 unsigned char reg = ReadCommand(0x22);
WiredHome 73:f22a18707b5e 968
WiredHome 40:04aa280dfa39 969 if (vScale == -1)
WiredHome 40:04aa280dfa39 970 vScale = hScale;
WiredHome 19:3f82c1161fd2 971 if (hScale >= 1 && hScale <= 4 && vScale >= 1 && vScale <= 4) {
WiredHome 19:3f82c1161fd2 972 reg &= 0xF0; // keep the high nibble as is.
WiredHome 19:3f82c1161fd2 973 reg |= ((hScale - 1) << 2);
WiredHome 19:3f82c1161fd2 974 reg |= ((vScale - 1) << 0);
WiredHome 19:3f82c1161fd2 975 WriteCommand(0x22, reg);
WiredHome 19:3f82c1161fd2 976 return noerror;
WiredHome 19:3f82c1161fd2 977 } else {
WiredHome 19:3f82c1161fd2 978 return bad_parameter;
WiredHome 19:3f82c1161fd2 979 }
WiredHome 19:3f82c1161fd2 980 }
WiredHome 19:3f82c1161fd2 981
WiredHome 127:db7f2c704693 982 RetCode_t RA8875::GetTextFontSize(RA8875::HorizontalScale * hScale, RA8875::VerticalScale * vScale)
WiredHome 127:db7f2c704693 983 {
WiredHome 127:db7f2c704693 984 unsigned char reg = ReadCommand(0x22);
WiredHome 127:db7f2c704693 985
WiredHome 127:db7f2c704693 986 if (hScale)
WiredHome 127:db7f2c704693 987 *hScale = 1 + (reg >> 2) & 0x03;
WiredHome 127:db7f2c704693 988 if (vScale)
WiredHome 127:db7f2c704693 989 *vScale = 1 + reg & 0x03;
WiredHome 127:db7f2c704693 990 return noerror;
WiredHome 127:db7f2c704693 991 }
WiredHome 44:207594dece70 992
WiredHome 19:3f82c1161fd2 993 int RA8875::_putc(int c)
WiredHome 19:3f82c1161fd2 994 {
WiredHome 29:422616aa04bd 995 if (font == NULL) {
WiredHome 29:422616aa04bd 996 return _internal_putc(c);
WiredHome 29:422616aa04bd 997 } else {
WiredHome 29:422616aa04bd 998 return _external_putc(c);
WiredHome 29:422616aa04bd 999 }
WiredHome 29:422616aa04bd 1000 }
WiredHome 29:422616aa04bd 1001
WiredHome 44:207594dece70 1002
WiredHome 101:e0aad446094a 1003
WiredHome 101:e0aad446094a 1004 // Questions to ponder -
WiredHome 101:e0aad446094a 1005 // - if we choose to wrap to the next line, because the character won't fit on the current line,
WiredHome 101:e0aad446094a 1006 // should it erase the space to the width of the screen (in case there is leftover junk there)?
WiredHome 101:e0aad446094a 1007 // - it currently wraps from the bottom of the screen back to the top. I have pondered what
WiredHome 101:e0aad446094a 1008 // it might take to scroll the screen - but haven't thought hard enough about it.
WiredHome 101:e0aad446094a 1009 //
WiredHome 29:422616aa04bd 1010 int RA8875::_external_putc(int c)
WiredHome 29:422616aa04bd 1011 {
WiredHome 19:3f82c1161fd2 1012 if (c) {
WiredHome 19:3f82c1161fd2 1013 if (c == '\r') {
WiredHome 111:efe436c43aba 1014 cursor_x = windowrect.p1.x;
WiredHome 29:422616aa04bd 1015 } else if (c == '\n') {
WiredHome 98:ecebed9b80b2 1016 cursor_y += extFontHeight;
WiredHome 29:422616aa04bd 1017 } else {
WiredHome 109:7b94f06f085b 1018 dim_t charWidth, charHeight;
WiredHome 101:e0aad446094a 1019 const uint8_t * charRecord;
WiredHome 101:e0aad446094a 1020
WiredHome 101:e0aad446094a 1021 charRecord = getCharMetrics(c, &charWidth, &charHeight);
WiredHome 101:e0aad446094a 1022 //int advance = charwidth(c);
WiredHome 111:efe436c43aba 1023 INFO("(%d,%d) - (%d,%d):(%d,%d), charWidth: %d '%c", cursor_x, cursor_y,
WiredHome 111:efe436c43aba 1024 windowrect.p1.x, windowrect.p1.y, windowrect.p2.x, windowrect.p2.y,
WiredHome 111:efe436c43aba 1025 charWidth, c);
WiredHome 101:e0aad446094a 1026 if (charRecord) {
WiredHome 101:e0aad446094a 1027 //cursor_x += advance;
WiredHome 111:efe436c43aba 1028 if (cursor_x + charWidth >= windowrect.p2.x) {
WiredHome 111:efe436c43aba 1029 cursor_x = windowrect.p1.x;
WiredHome 101:e0aad446094a 1030 cursor_y += charHeight;
WiredHome 29:422616aa04bd 1031 }
WiredHome 111:efe436c43aba 1032 if (cursor_y + charHeight >= windowrect.p2.y) {
WiredHome 111:efe436c43aba 1033 cursor_y = windowrect.p1.y; // @todo Should it scroll?
WiredHome 101:e0aad446094a 1034 }
WiredHome 101:e0aad446094a 1035 (void)character(cursor_x, cursor_y, c);
WiredHome 101:e0aad446094a 1036 cursor_x += charWidth;
WiredHome 29:422616aa04bd 1037 }
WiredHome 29:422616aa04bd 1038 }
WiredHome 29:422616aa04bd 1039 }
WiredHome 29:422616aa04bd 1040 return c;
WiredHome 29:422616aa04bd 1041 }
WiredHome 29:422616aa04bd 1042
WiredHome 44:207594dece70 1043
WiredHome 29:422616aa04bd 1044 int RA8875::_internal_putc(int c)
WiredHome 29:422616aa04bd 1045 {
WiredHome 29:422616aa04bd 1046 if (c) {
WiredHome 29:422616aa04bd 1047 unsigned char mwcr0;
WiredHome 73:f22a18707b5e 1048
WiredHome 29:422616aa04bd 1049 mwcr0 = ReadCommand(0x40);
WiredHome 29:422616aa04bd 1050 if ((mwcr0 & 0x80) == 0x00) {
WiredHome 29:422616aa04bd 1051 WriteCommand(0x40, 0x80 | mwcr0); // Put in Text mode if not already
WiredHome 29:422616aa04bd 1052 }
WiredHome 29:422616aa04bd 1053 if (c == '\r') {
WiredHome 37:f19b7e7449dc 1054 loc_t x;
WiredHome 19:3f82c1161fd2 1055 x = ReadCommand(0x30) | (ReadCommand(0x31) << 8); // Left edge of active window
WiredHome 38:38d503b4fad6 1056 WriteCommandW(0x2A, x);
WiredHome 19:3f82c1161fd2 1057 } else if (c == '\n') {
WiredHome 37:f19b7e7449dc 1058 loc_t y;
WiredHome 19:3f82c1161fd2 1059 y = ReadCommand(0x2C) | (ReadCommand(0x2D) << 8); // current y location
WiredHome 19:3f82c1161fd2 1060 y += fontheight();
WiredHome 47:d96a09269f91 1061 if (y >= height()) // @TODO after bottom of active window, then scroll window?
WiredHome 19:3f82c1161fd2 1062 y = 0;
WiredHome 38:38d503b4fad6 1063 WriteCommandW(0x2C, y);
WiredHome 19:3f82c1161fd2 1064 } else {
WiredHome 29:422616aa04bd 1065 WriteCommand(0x02); // RA8875 Internal Fonts
WiredHome 79:544eb4964795 1066 _select(true);
WiredHome 29:422616aa04bd 1067 WriteData(c);
WiredHome 66:468a11f05580 1068 _WaitWhileBusy(0x80);
WiredHome 79:544eb4964795 1069 _select(false);
WiredHome 19:3f82c1161fd2 1070 }
WiredHome 19:3f82c1161fd2 1071 }
WiredHome 19:3f82c1161fd2 1072 return c;
WiredHome 19:3f82c1161fd2 1073 }
WiredHome 19:3f82c1161fd2 1074
WiredHome 44:207594dece70 1075
WiredHome 32:0e4f2ae512e2 1076 RetCode_t RA8875::_StartGraphicsStream(void)
WiredHome 32:0e4f2ae512e2 1077 {
WiredHome 32:0e4f2ae512e2 1078 WriteCommand(0x40,0x00); // Graphics write mode
WiredHome 32:0e4f2ae512e2 1079 WriteCommand(0x02); // Prepare for streaming data
WiredHome 32:0e4f2ae512e2 1080 return noerror;
WiredHome 32:0e4f2ae512e2 1081 }
WiredHome 32:0e4f2ae512e2 1082
WiredHome 44:207594dece70 1083
WiredHome 32:0e4f2ae512e2 1084 RetCode_t RA8875::_EndGraphicsStream(void)
WiredHome 32:0e4f2ae512e2 1085 {
WiredHome 32:0e4f2ae512e2 1086 return noerror;
WiredHome 32:0e4f2ae512e2 1087 }
WiredHome 32:0e4f2ae512e2 1088
WiredHome 44:207594dece70 1089
WiredHome 55:dfbabef7003e 1090 RetCode_t RA8875::_putp(color_t pixel)
WiredHome 32:0e4f2ae512e2 1091 {
WiredHome 38:38d503b4fad6 1092 WriteDataW((pixel>>8) | (pixel<<8));
WiredHome 73:f22a18707b5e 1093 return noerror;
WiredHome 32:0e4f2ae512e2 1094 }
WiredHome 29:422616aa04bd 1095
WiredHome 44:207594dece70 1096
WiredHome 37:f19b7e7449dc 1097 void RA8875::puts(loc_t x, loc_t y, const char * string)
WiredHome 19:3f82c1161fd2 1098 {
WiredHome 19:3f82c1161fd2 1099 SetTextCursor(x,y);
WiredHome 19:3f82c1161fd2 1100 puts(string);
WiredHome 19:3f82c1161fd2 1101 }
WiredHome 19:3f82c1161fd2 1102
WiredHome 44:207594dece70 1103
WiredHome 19:3f82c1161fd2 1104 void RA8875::puts(const char * string)
WiredHome 19:3f82c1161fd2 1105 {
WiredHome 37:f19b7e7449dc 1106 if (font == NULL) {
WiredHome 100:0b084475d5a9 1107 WriteCommand(0x40,0x80); // Put in Text mode if internal font
WiredHome 37:f19b7e7449dc 1108 }
WiredHome 19:3f82c1161fd2 1109 if (*string != '\0') {
WiredHome 29:422616aa04bd 1110 while (*string) { // @TODO calling individual _putc is slower... optimizations?
WiredHome 19:3f82c1161fd2 1111 _putc(*string++);
WiredHome 19:3f82c1161fd2 1112 }
WiredHome 19:3f82c1161fd2 1113 }
WiredHome 19:3f82c1161fd2 1114 }
WiredHome 19:3f82c1161fd2 1115
WiredHome 44:207594dece70 1116
WiredHome 37:f19b7e7449dc 1117 RetCode_t RA8875::SetGraphicsCursor(loc_t x, loc_t y)
WiredHome 19:3f82c1161fd2 1118 {
WiredHome 38:38d503b4fad6 1119 WriteCommandW(0x46, x);
WiredHome 38:38d503b4fad6 1120 WriteCommandW(0x48, y);
WiredHome 19:3f82c1161fd2 1121 return noerror;
WiredHome 19:3f82c1161fd2 1122 }
WiredHome 19:3f82c1161fd2 1123
WiredHome 44:207594dece70 1124
WiredHome 41:2956a0a221e5 1125 RetCode_t RA8875::SetGraphicsCursorRead(loc_t x, loc_t y)
WiredHome 41:2956a0a221e5 1126 {
WiredHome 41:2956a0a221e5 1127 WriteCommandW(0x4A, x);
WiredHome 41:2956a0a221e5 1128 WriteCommandW(0x4C, y);
WiredHome 41:2956a0a221e5 1129 return noerror;
WiredHome 41:2956a0a221e5 1130 }
WiredHome 41:2956a0a221e5 1131
WiredHome 111:efe436c43aba 1132 RetCode_t RA8875::window(rect_t r)
WiredHome 111:efe436c43aba 1133 {
WiredHome 111:efe436c43aba 1134 return window(r.p1.x, r.p1.y, r.p2.x + 1 - r.p1.x, r.p2.y + 1 - r.p1.y);
WiredHome 111:efe436c43aba 1135 }
WiredHome 44:207594dece70 1136
WiredHome 37:f19b7e7449dc 1137 RetCode_t RA8875::window(loc_t x, loc_t y, dim_t width, dim_t height)
WiredHome 19:3f82c1161fd2 1138 {
WiredHome 111:efe436c43aba 1139 INFO("window(%d,%d,%d,%d)", x, y, width, height);
WiredHome 111:efe436c43aba 1140 if (width == (dim_t)-1)
WiredHome 111:efe436c43aba 1141 width = screenwidth - x;
WiredHome 111:efe436c43aba 1142 if (height == (dim_t)-1)
WiredHome 111:efe436c43aba 1143 height = screenheight - y;
WiredHome 111:efe436c43aba 1144 windowrect.p1.x = x;
WiredHome 111:efe436c43aba 1145 windowrect.p1.y = y;
WiredHome 111:efe436c43aba 1146 windowrect.p2.x = x + width - 1;
WiredHome 111:efe436c43aba 1147 windowrect.p2.y = y + height - 1;
WiredHome 37:f19b7e7449dc 1148 GraphicsDisplay::window(x,y, width,height);
WiredHome 38:38d503b4fad6 1149 WriteCommandW(0x30, x);
WiredHome 38:38d503b4fad6 1150 WriteCommandW(0x32, y);
WiredHome 38:38d503b4fad6 1151 WriteCommandW(0x34, (x+width-1));
WiredHome 38:38d503b4fad6 1152 WriteCommandW(0x36, (y+height-1));
WiredHome 111:efe436c43aba 1153 //SetTextCursor(x,y);
WiredHome 111:efe436c43aba 1154 //SetGraphicsCursor(x,y);
WiredHome 19:3f82c1161fd2 1155 return noerror;
WiredHome 19:3f82c1161fd2 1156 }
WiredHome 19:3f82c1161fd2 1157
WiredHome 44:207594dece70 1158
WiredHome 61:8f3153bf0baa 1159 RetCode_t RA8875::cls(uint16_t layers)
WiredHome 19:3f82c1161fd2 1160 {
WiredHome 61:8f3153bf0baa 1161 RetCode_t ret;
WiredHome 73:f22a18707b5e 1162
WiredHome 19:3f82c1161fd2 1163 PERFORMANCE_RESET;
WiredHome 61:8f3153bf0baa 1164 if (layers == 0) {
WiredHome 61:8f3153bf0baa 1165 ret = clsw(FULLWINDOW);
WiredHome 61:8f3153bf0baa 1166 } else if (layers > 3) {
WiredHome 61:8f3153bf0baa 1167 ret = bad_parameter;
WiredHome 61:8f3153bf0baa 1168 } else {
WiredHome 61:8f3153bf0baa 1169 uint16_t prevLayer = GetDrawingLayer();
WiredHome 61:8f3153bf0baa 1170 if (layers & 1) {
WiredHome 61:8f3153bf0baa 1171 SelectDrawingLayer(0);
WiredHome 61:8f3153bf0baa 1172 clsw(FULLWINDOW);
WiredHome 61:8f3153bf0baa 1173 }
WiredHome 61:8f3153bf0baa 1174 if (layers & 2) {
WiredHome 61:8f3153bf0baa 1175 SelectDrawingLayer(1);
WiredHome 61:8f3153bf0baa 1176 clsw(FULLWINDOW);
WiredHome 61:8f3153bf0baa 1177 }
WiredHome 61:8f3153bf0baa 1178 ret = SelectDrawingLayer(prevLayer);
WiredHome 61:8f3153bf0baa 1179 }
WiredHome 135:af519fe4ba91 1180 ret = SetTextCursor(0,0);
WiredHome 135:af519fe4ba91 1181 ret = locate(0,0);
WiredHome 19:3f82c1161fd2 1182 REGISTERPERFORMANCE(PRF_CLS);
WiredHome 61:8f3153bf0baa 1183 return ret;
WiredHome 19:3f82c1161fd2 1184 }
WiredHome 19:3f82c1161fd2 1185
WiredHome 44:207594dece70 1186
WiredHome 19:3f82c1161fd2 1187 RetCode_t RA8875::clsw(RA8875::Region_t region)
WiredHome 19:3f82c1161fd2 1188 {
WiredHome 19:3f82c1161fd2 1189 PERFORMANCE_RESET;
WiredHome 19:3f82c1161fd2 1190 WriteCommand(0x8E, (region == ACTIVEWINDOW) ? 0xC0 : 0x80);
WiredHome 131:5bd6ba2ee4a1 1191 if (!_WaitWhileReg(0x8E, 0x80)) {
WiredHome 131:5bd6ba2ee4a1 1192 REGISTERPERFORMANCE(PRF_CLS);
WiredHome 131:5bd6ba2ee4a1 1193 return external_abort;
WiredHome 131:5bd6ba2ee4a1 1194 }
WiredHome 19:3f82c1161fd2 1195 REGISTERPERFORMANCE(PRF_CLS);
WiredHome 19:3f82c1161fd2 1196 return noerror;
WiredHome 19:3f82c1161fd2 1197 }
WiredHome 19:3f82c1161fd2 1198
WiredHome 44:207594dece70 1199
WiredHome 87:ee2240581aa7 1200 RetCode_t RA8875::pixel(point_t p, color_t color)
WiredHome 87:ee2240581aa7 1201 {
WiredHome 87:ee2240581aa7 1202 return pixel(p.x, p.y, color);
WiredHome 87:ee2240581aa7 1203 }
WiredHome 87:ee2240581aa7 1204
WiredHome 87:ee2240581aa7 1205 RetCode_t RA8875::pixel(point_t p)
WiredHome 87:ee2240581aa7 1206 {
WiredHome 87:ee2240581aa7 1207 return pixel(p.x, p.y);
WiredHome 87:ee2240581aa7 1208 }
WiredHome 87:ee2240581aa7 1209
WiredHome 37:f19b7e7449dc 1210 RetCode_t RA8875::pixel(loc_t x, loc_t y, color_t color)
WiredHome 19:3f82c1161fd2 1211 {
WiredHome 62:ba5d33438fda 1212 RetCode_t ret;
WiredHome 73:f22a18707b5e 1213
WiredHome 62:ba5d33438fda 1214 PERFORMANCE_RESET;
WiredHome 62:ba5d33438fda 1215 ret = pixelStream(&color, 1, x,y);
WiredHome 62:ba5d33438fda 1216 REGISTERPERFORMANCE(PRF_DRAWPIXEL);
WiredHome 62:ba5d33438fda 1217 return ret;
WiredHome 19:3f82c1161fd2 1218 }
WiredHome 19:3f82c1161fd2 1219
WiredHome 44:207594dece70 1220
WiredHome 37:f19b7e7449dc 1221 RetCode_t RA8875::pixel(loc_t x, loc_t y)
WiredHome 19:3f82c1161fd2 1222 {
WiredHome 19:3f82c1161fd2 1223 RetCode_t ret;
WiredHome 73:f22a18707b5e 1224
WiredHome 19:3f82c1161fd2 1225 PERFORMANCE_RESET;
WiredHome 19:3f82c1161fd2 1226 color_t color = GetForeColor();
WiredHome 62:ba5d33438fda 1227 ret = pixelStream(&color, 1, x, y);
WiredHome 41:2956a0a221e5 1228 REGISTERPERFORMANCE(PRF_DRAWPIXEL);
WiredHome 19:3f82c1161fd2 1229 return ret;
WiredHome 19:3f82c1161fd2 1230 }
WiredHome 19:3f82c1161fd2 1231
WiredHome 44:207594dece70 1232
WiredHome 41:2956a0a221e5 1233 RetCode_t RA8875::pixelStream(color_t * p, uint32_t count, loc_t x, loc_t y)
WiredHome 41:2956a0a221e5 1234 {
WiredHome 41:2956a0a221e5 1235 PERFORMANCE_RESET;
WiredHome 41:2956a0a221e5 1236 SetGraphicsCursor(x, y);
WiredHome 109:7b94f06f085b 1237 _StartGraphicsStream();
WiredHome 79:544eb4964795 1238 _select(true);
WiredHome 79:544eb4964795 1239 _spiwrite(0x00); // Cmd: write data
WiredHome 41:2956a0a221e5 1240 while (count--) {
WiredHome 105:4f116006ba1f 1241 if (screenbpp == 16) {
WiredHome 105:4f116006ba1f 1242 _spiwrite(*p >> 8);
WiredHome 105:4f116006ba1f 1243 _spiwrite(*p & 0xFF);
WiredHome 105:4f116006ba1f 1244 } else {
WiredHome 105:4f116006ba1f 1245 _spiwrite(_cvt16to8(*p));
WiredHome 105:4f116006ba1f 1246 }
WiredHome 41:2956a0a221e5 1247 p++;
WiredHome 41:2956a0a221e5 1248 }
WiredHome 79:544eb4964795 1249 _select(false);
WiredHome 109:7b94f06f085b 1250 _EndGraphicsStream();
WiredHome 41:2956a0a221e5 1251 REGISTERPERFORMANCE(PRF_PIXELSTREAM);
WiredHome 41:2956a0a221e5 1252 return(noerror);
WiredHome 41:2956a0a221e5 1253 }
WiredHome 41:2956a0a221e5 1254
WiredHome 109:7b94f06f085b 1255 RetCode_t RA8875::booleanStream(loc_t x, loc_t y, dim_t w, dim_t h, const uint8_t * boolStream)
WiredHome 109:7b94f06f085b 1256 {
WiredHome 109:7b94f06f085b 1257 PERFORMANCE_RESET;
WiredHome 111:efe436c43aba 1258 rect_t restore = windowrect;
WiredHome 111:efe436c43aba 1259
WiredHome 109:7b94f06f085b 1260 window(x, y, w, h);
WiredHome 109:7b94f06f085b 1261 SetGraphicsCursor(x, y);
WiredHome 109:7b94f06f085b 1262 _StartGraphicsStream();
WiredHome 109:7b94f06f085b 1263 _select(true);
WiredHome 109:7b94f06f085b 1264 _spiwrite(0x00); // Cmd: write data
WiredHome 109:7b94f06f085b 1265 while (h--) {
WiredHome 109:7b94f06f085b 1266 uint8_t pixels = w;
WiredHome 109:7b94f06f085b 1267 uint8_t bitmask = 0x01;
WiredHome 109:7b94f06f085b 1268
WiredHome 109:7b94f06f085b 1269 while (pixels) {
WiredHome 109:7b94f06f085b 1270 uint8_t byte = *boolStream;
WiredHome 111:efe436c43aba 1271 //INFO("byte, mask: %02X, %02X", byte, bitmask);
WiredHome 109:7b94f06f085b 1272 color_t c = (byte & bitmask) ? _foreground : _background;
WiredHome 109:7b94f06f085b 1273 if (screenbpp == 16) {
WiredHome 109:7b94f06f085b 1274 _spiwrite(c >> 8);
WiredHome 109:7b94f06f085b 1275 _spiwrite(c & 0xFF);
WiredHome 109:7b94f06f085b 1276 } else {
WiredHome 109:7b94f06f085b 1277 _spiwrite(_cvt16to8(c));
WiredHome 109:7b94f06f085b 1278 }
WiredHome 109:7b94f06f085b 1279 bitmask <<= 1;
WiredHome 109:7b94f06f085b 1280 if (pixels > 1 && bitmask == 0) {
WiredHome 109:7b94f06f085b 1281 bitmask = 0x01;
WiredHome 109:7b94f06f085b 1282 boolStream++;
WiredHome 109:7b94f06f085b 1283 }
WiredHome 109:7b94f06f085b 1284 pixels--;
WiredHome 109:7b94f06f085b 1285 }
WiredHome 109:7b94f06f085b 1286 boolStream++;
WiredHome 109:7b94f06f085b 1287 }
WiredHome 109:7b94f06f085b 1288 _select(false);
WiredHome 109:7b94f06f085b 1289 _EndGraphicsStream();
WiredHome 111:efe436c43aba 1290 window(restore);
WiredHome 109:7b94f06f085b 1291 REGISTERPERFORMANCE(PRF_BOOLSTREAM);
WiredHome 109:7b94f06f085b 1292 return(noerror);
WiredHome 109:7b94f06f085b 1293 }
WiredHome 44:207594dece70 1294
WiredHome 41:2956a0a221e5 1295 color_t RA8875::getPixel(loc_t x, loc_t y)
WiredHome 41:2956a0a221e5 1296 {
WiredHome 41:2956a0a221e5 1297 color_t pixel;
WiredHome 73:f22a18707b5e 1298
WiredHome 41:2956a0a221e5 1299 PERFORMANCE_RESET;
WiredHome 41:2956a0a221e5 1300 WriteCommand(0x40,0x00); // Graphics write mode
WiredHome 41:2956a0a221e5 1301 SetGraphicsCursorRead(x, y);
WiredHome 41:2956a0a221e5 1302 WriteCommand(0x02);
WiredHome 79:544eb4964795 1303 _select(true);
WiredHome 79:544eb4964795 1304 _spiwrite(0x40); // Cmd: read data
WiredHome 79:544eb4964795 1305 _spiwrite(0x00); // dummy read
WiredHome 105:4f116006ba1f 1306 if (screenbpp == 16) {
WiredHome 105:4f116006ba1f 1307 pixel = _spiread();
WiredHome 105:4f116006ba1f 1308 pixel |= (_spiread() << 8);
WiredHome 105:4f116006ba1f 1309 } else {
WiredHome 105:4f116006ba1f 1310 pixel = _cvt8to16(_spiread());
WiredHome 105:4f116006ba1f 1311 }
WiredHome 79:544eb4964795 1312 _select(false);
WiredHome 41:2956a0a221e5 1313 REGISTERPERFORMANCE(PRF_READPIXEL);
WiredHome 41:2956a0a221e5 1314 return pixel;
WiredHome 41:2956a0a221e5 1315 }
WiredHome 41:2956a0a221e5 1316
WiredHome 44:207594dece70 1317
WiredHome 41:2956a0a221e5 1318 RetCode_t RA8875::getPixelStream(color_t * p, uint32_t count, loc_t x, loc_t y)
WiredHome 41:2956a0a221e5 1319 {
WiredHome 41:2956a0a221e5 1320 color_t pixel;
WiredHome 86:e86b355940f4 1321 RetCode_t ret = noerror;
WiredHome 73:f22a18707b5e 1322
WiredHome 41:2956a0a221e5 1323 PERFORMANCE_RESET;
WiredHome 86:e86b355940f4 1324 ret = WriteCommand(0x40,0x00); // Graphics write mode
WiredHome 86:e86b355940f4 1325 ret = SetGraphicsCursorRead(x, y);
WiredHome 86:e86b355940f4 1326 ret = WriteCommand(0x02);
WiredHome 79:544eb4964795 1327 _select(true);
WiredHome 79:544eb4964795 1328 _spiwrite(0x40); // Cmd: read data
WiredHome 79:544eb4964795 1329 _spiwrite(0x00); // dummy read
WiredHome 106:c80828f5dea4 1330 if (screenbpp == 16)
WiredHome 106:c80828f5dea4 1331 _spiwrite(0x00); // dummy read is only necessary when in 16-bit mode
WiredHome 41:2956a0a221e5 1332 while (count--) {
WiredHome 105:4f116006ba1f 1333 if (screenbpp == 16) {
WiredHome 105:4f116006ba1f 1334 pixel = _spiread();
WiredHome 105:4f116006ba1f 1335 pixel |= (_spiread() << 8);
WiredHome 105:4f116006ba1f 1336 } else {
WiredHome 105:4f116006ba1f 1337 pixel = _cvt8to16(_spiread());
WiredHome 105:4f116006ba1f 1338 }
WiredHome 41:2956a0a221e5 1339 *p++ = pixel;
WiredHome 41:2956a0a221e5 1340 }
WiredHome 79:544eb4964795 1341 _select(false);
WiredHome 41:2956a0a221e5 1342 REGISTERPERFORMANCE(PRF_READPIXELSTREAM);
WiredHome 86:e86b355940f4 1343 return ret;
WiredHome 41:2956a0a221e5 1344 }
WiredHome 41:2956a0a221e5 1345
WiredHome 44:207594dece70 1346
WiredHome 83:7bad0068cca0 1347 RetCode_t RA8875::line(point_t p1, point_t p2)
WiredHome 83:7bad0068cca0 1348 {
WiredHome 83:7bad0068cca0 1349 return line(p1.x, p1.y, p2.x, p2.y);
WiredHome 83:7bad0068cca0 1350 }
WiredHome 83:7bad0068cca0 1351
WiredHome 83:7bad0068cca0 1352
WiredHome 83:7bad0068cca0 1353 RetCode_t RA8875::line(point_t p1, point_t p2, color_t color)
WiredHome 83:7bad0068cca0 1354 {
WiredHome 83:7bad0068cca0 1355 return line(p1.x, p1.y, p2.x, p2.y, color);
WiredHome 83:7bad0068cca0 1356 }
WiredHome 83:7bad0068cca0 1357
WiredHome 83:7bad0068cca0 1358
WiredHome 37:f19b7e7449dc 1359 RetCode_t RA8875::line(loc_t x1, loc_t y1, loc_t x2, loc_t y2, color_t color)
WiredHome 19:3f82c1161fd2 1360 {
WiredHome 19:3f82c1161fd2 1361 foreground(color);
WiredHome 19:3f82c1161fd2 1362 return line(x1,y1,x2,y2);
WiredHome 19:3f82c1161fd2 1363 }
WiredHome 19:3f82c1161fd2 1364
WiredHome 44:207594dece70 1365
WiredHome 37:f19b7e7449dc 1366 RetCode_t RA8875::line(loc_t x1, loc_t y1, loc_t x2, loc_t y2)
WiredHome 19:3f82c1161fd2 1367 {
WiredHome 19:3f82c1161fd2 1368 PERFORMANCE_RESET;
WiredHome 62:ba5d33438fda 1369 if (x1 == x2 && y1 == y2) {
WiredHome 60:2dfd574f63bd 1370 pixel(x1, y1);
WiredHome 62:ba5d33438fda 1371 } else {
WiredHome 60:2dfd574f63bd 1372 WriteCommandW(0x91, x1);
WiredHome 60:2dfd574f63bd 1373 WriteCommandW(0x93, y1);
WiredHome 60:2dfd574f63bd 1374 WriteCommandW(0x95, x2);
WiredHome 60:2dfd574f63bd 1375 WriteCommandW(0x97, y2);
WiredHome 60:2dfd574f63bd 1376 unsigned char drawCmd = 0x00; // Line
WiredHome 60:2dfd574f63bd 1377 WriteCommand(0x90, drawCmd);
WiredHome 60:2dfd574f63bd 1378 WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
WiredHome 131:5bd6ba2ee4a1 1379 if (!_WaitWhileReg(0x90, 0x80)) {
WiredHome 131:5bd6ba2ee4a1 1380 REGISTERPERFORMANCE(PRF_DRAWLINE);
WiredHome 131:5bd6ba2ee4a1 1381 return external_abort;
WiredHome 131:5bd6ba2ee4a1 1382 }
WiredHome 60:2dfd574f63bd 1383 }
WiredHome 19:3f82c1161fd2 1384 REGISTERPERFORMANCE(PRF_DRAWLINE);
WiredHome 19:3f82c1161fd2 1385 return noerror;
WiredHome 19:3f82c1161fd2 1386 }
WiredHome 19:3f82c1161fd2 1387
WiredHome 107:f9ccffcb84f1 1388 //
WiredHome 107:f9ccffcb84f1 1389 // Rectangle functions all mostly helpers to the basic rectangle function
WiredHome 107:f9ccffcb84f1 1390 //
WiredHome 107:f9ccffcb84f1 1391
WiredHome 81:01da2e34283d 1392 RetCode_t RA8875::fillrect(rect_t r, color_t color, fill_t fillit)
WiredHome 81:01da2e34283d 1393 {
WiredHome 81:01da2e34283d 1394 return rect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, color, fillit);
WiredHome 81:01da2e34283d 1395 }
WiredHome 44:207594dece70 1396
WiredHome 73:f22a18707b5e 1397 RetCode_t RA8875::fillrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1398 color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1399 {
WiredHome 19:3f82c1161fd2 1400 return rect(x1,y1,x2,y2,color,fillit);
WiredHome 19:3f82c1161fd2 1401 }
WiredHome 19:3f82c1161fd2 1402
WiredHome 81:01da2e34283d 1403 RetCode_t RA8875::rect(rect_t r, color_t color, fill_t fillit)
WiredHome 81:01da2e34283d 1404 {
WiredHome 81:01da2e34283d 1405 return rect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, color, fillit);
WiredHome 81:01da2e34283d 1406 }
WiredHome 44:207594dece70 1407
WiredHome 73:f22a18707b5e 1408 RetCode_t RA8875::rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1409 color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1410 {
WiredHome 19:3f82c1161fd2 1411 foreground(color);
WiredHome 19:3f82c1161fd2 1412 return rect(x1,y1,x2,y2,fillit);
WiredHome 19:3f82c1161fd2 1413 }
WiredHome 19:3f82c1161fd2 1414
WiredHome 73:f22a18707b5e 1415 RetCode_t RA8875::rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1416 fill_t fillit)
WiredHome 19:3f82c1161fd2 1417 {
WiredHome 85:022bba13c5c4 1418 RetCode_t ret = noerror;
WiredHome 19:3f82c1161fd2 1419 PERFORMANCE_RESET;
WiredHome 85:022bba13c5c4 1420 // check for bad_parameter
WiredHome 105:4f116006ba1f 1421 if (x1 < 0 || x1 >= screenwidth || x2 < 0 || x2 >= screenwidth
WiredHome 105:4f116006ba1f 1422 || y1 < 0 || y1 >= screenheight || y2 < 0 || y2 >= screenheight) {
WiredHome 85:022bba13c5c4 1423 ret = bad_parameter;
WiredHome 100:0b084475d5a9 1424 } else {
WiredHome 85:022bba13c5c4 1425 if (x1 == x2 && y1 == y2) {
WiredHome 85:022bba13c5c4 1426 pixel(x1, y1);
WiredHome 85:022bba13c5c4 1427 } else if (x1 == x2) {
WiredHome 85:022bba13c5c4 1428 line(x1, y1, x2, y2);
WiredHome 85:022bba13c5c4 1429 } else if (y1 == y2) {
WiredHome 85:022bba13c5c4 1430 line(x1, y1, x2, y2);
WiredHome 85:022bba13c5c4 1431 } else {
WiredHome 85:022bba13c5c4 1432 WriteCommandW(0x91, x1);
WiredHome 85:022bba13c5c4 1433 WriteCommandW(0x93, y1);
WiredHome 85:022bba13c5c4 1434 WriteCommandW(0x95, x2);
WiredHome 85:022bba13c5c4 1435 WriteCommandW(0x97, y2);
WiredHome 85:022bba13c5c4 1436 unsigned char drawCmd = 0x10; // Rectangle
WiredHome 85:022bba13c5c4 1437 if (fillit == FILL)
WiredHome 85:022bba13c5c4 1438 drawCmd |= 0x20;
WiredHome 85:022bba13c5c4 1439 WriteCommand(0x90, drawCmd);
WiredHome 85:022bba13c5c4 1440 ret = WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
WiredHome 131:5bd6ba2ee4a1 1441 if (!_WaitWhileReg(0x90, 0x80)) {
WiredHome 131:5bd6ba2ee4a1 1442 REGISTERPERFORMANCE(PRF_DRAWRECTANGLE);
WiredHome 131:5bd6ba2ee4a1 1443 return external_abort;
WiredHome 131:5bd6ba2ee4a1 1444 }
WiredHome 85:022bba13c5c4 1445 }
WiredHome 19:3f82c1161fd2 1446 }
WiredHome 19:3f82c1161fd2 1447 REGISTERPERFORMANCE(PRF_DRAWRECTANGLE);
WiredHome 85:022bba13c5c4 1448 return ret;
WiredHome 19:3f82c1161fd2 1449 }
WiredHome 19:3f82c1161fd2 1450
WiredHome 44:207594dece70 1451
WiredHome 107:f9ccffcb84f1 1452 //
WiredHome 107:f9ccffcb84f1 1453 // rounded rectangle functions are mostly helpers to the base round rect
WiredHome 107:f9ccffcb84f1 1454 //
WiredHome 107:f9ccffcb84f1 1455
WiredHome 107:f9ccffcb84f1 1456 RetCode_t RA8875::fillroundrect(rect_t r, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 107:f9ccffcb84f1 1457 {
WiredHome 107:f9ccffcb84f1 1458 return roundrect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, radius1, radius2, color, fillit);
WiredHome 107:f9ccffcb84f1 1459 }
WiredHome 107:f9ccffcb84f1 1460
WiredHome 73:f22a18707b5e 1461 RetCode_t RA8875::fillroundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1462 dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1463 {
WiredHome 19:3f82c1161fd2 1464 foreground(color);
WiredHome 19:3f82c1161fd2 1465 return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
WiredHome 19:3f82c1161fd2 1466 }
WiredHome 19:3f82c1161fd2 1467
WiredHome 107:f9ccffcb84f1 1468 RetCode_t RA8875::roundrect(rect_t r, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 107:f9ccffcb84f1 1469 {
WiredHome 107:f9ccffcb84f1 1470 return roundrect(r.p1.x, r.p1.y, r.p2.x, r.p2.y, radius1, radius2, color, fillit);
WiredHome 107:f9ccffcb84f1 1471 }
WiredHome 44:207594dece70 1472
WiredHome 73:f22a18707b5e 1473 RetCode_t RA8875::roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1474 dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1475 {
WiredHome 19:3f82c1161fd2 1476 foreground(color);
WiredHome 19:3f82c1161fd2 1477 return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
WiredHome 19:3f82c1161fd2 1478 }
WiredHome 19:3f82c1161fd2 1479
WiredHome 44:207594dece70 1480
WiredHome 73:f22a18707b5e 1481 RetCode_t RA8875::roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1482 dim_t radius1, dim_t radius2, fill_t fillit)
WiredHome 19:3f82c1161fd2 1483 {
WiredHome 19:3f82c1161fd2 1484 RetCode_t ret = noerror;
WiredHome 73:f22a18707b5e 1485
WiredHome 19:3f82c1161fd2 1486 PERFORMANCE_RESET;
WiredHome 105:4f116006ba1f 1487 if (x1 < 0 || x1 >= screenwidth || x2 < 0 || x2 >= screenwidth
WiredHome 105:4f116006ba1f 1488 || y1 < 0 || y1 >= screenheight || y2 < 0 || y2 >= screenheight) {
WiredHome 85:022bba13c5c4 1489 ret = bad_parameter;
WiredHome 85:022bba13c5c4 1490 } else if (x1 > x2 || y1 > y2 || (radius1 > (x2-x1)/2) || (radius2 > (y2-y1)/2) ) {
WiredHome 21:3c1efb192927 1491 ret = bad_parameter;
WiredHome 21:3c1efb192927 1492 } else if (x1 == x2 && y1 == y2) {
WiredHome 19:3f82c1161fd2 1493 pixel(x1, y1);
WiredHome 19:3f82c1161fd2 1494 } else if (x1 == x2) {
WiredHome 19:3f82c1161fd2 1495 line(x1, y1, x2, y2);
WiredHome 19:3f82c1161fd2 1496 } else if (y1 == y2) {
WiredHome 19:3f82c1161fd2 1497 line(x1, y1, x2, y2);
WiredHome 19:3f82c1161fd2 1498 } else {
WiredHome 38:38d503b4fad6 1499 WriteCommandW(0x91, x1);
WiredHome 38:38d503b4fad6 1500 WriteCommandW(0x93, y1);
WiredHome 38:38d503b4fad6 1501 WriteCommandW(0x95, x2);
WiredHome 38:38d503b4fad6 1502 WriteCommandW(0x97, y2);
WiredHome 38:38d503b4fad6 1503 WriteCommandW(0xA1, radius1);
WiredHome 38:38d503b4fad6 1504 WriteCommandW(0xA3, radius2);
WiredHome 21:3c1efb192927 1505 // Should not need this...
WiredHome 38:38d503b4fad6 1506 WriteCommandW(0xA5, 0);
WiredHome 38:38d503b4fad6 1507 WriteCommandW(0xA7, 0);
WiredHome 19:3f82c1161fd2 1508 unsigned char drawCmd = 0x20; // Rounded Rectangle
WiredHome 19:3f82c1161fd2 1509 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 1510 drawCmd |= 0x40;
WiredHome 19:3f82c1161fd2 1511 WriteCommand(0xA0, drawCmd);
WiredHome 19:3f82c1161fd2 1512 WriteCommand(0xA0, 0x80 + drawCmd); // Start drawing.
WiredHome 131:5bd6ba2ee4a1 1513 if (!_WaitWhileReg(0xA0, 0x80)) {
WiredHome 131:5bd6ba2ee4a1 1514 REGISTERPERFORMANCE(PRF_DRAWROUNDEDRECTANGLE);
WiredHome 131:5bd6ba2ee4a1 1515 return external_abort;
WiredHome 131:5bd6ba2ee4a1 1516 }
WiredHome 19:3f82c1161fd2 1517 }
WiredHome 19:3f82c1161fd2 1518 REGISTERPERFORMANCE(PRF_DRAWROUNDEDRECTANGLE);
WiredHome 19:3f82c1161fd2 1519 return ret;
WiredHome 19:3f82c1161fd2 1520 }
WiredHome 19:3f82c1161fd2 1521
WiredHome 44:207594dece70 1522
WiredHome 107:f9ccffcb84f1 1523 //
WiredHome 107:f9ccffcb84f1 1524 // triangle functions
WiredHome 107:f9ccffcb84f1 1525 //
WiredHome 107:f9ccffcb84f1 1526
WiredHome 73:f22a18707b5e 1527 RetCode_t RA8875::triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1528 loc_t x3, loc_t y3, color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1529 {
WiredHome 20:6e2e4a8372eb 1530 RetCode_t ret;
WiredHome 20:6e2e4a8372eb 1531
WiredHome 105:4f116006ba1f 1532 if (x1 < 0 || x1 >= screenwidth || x2 < 0 || x2 >= screenwidth || x3 < 0 || x3 >= screenwidth
WiredHome 105:4f116006ba1f 1533 || y1 < 0 || y1 >= screenheight || y2 < 0 || y2 >= screenheight || y3 < 0 || y3 >= screenheight)
WiredHome 85:022bba13c5c4 1534 ret = bad_parameter;
WiredHome 19:3f82c1161fd2 1535 foreground(color);
WiredHome 20:6e2e4a8372eb 1536 ret = triangle(x1,y1,x2,y2,x3,y3,fillit);
WiredHome 20:6e2e4a8372eb 1537 return ret;
WiredHome 19:3f82c1161fd2 1538 }
WiredHome 19:3f82c1161fd2 1539
WiredHome 44:207594dece70 1540
WiredHome 73:f22a18707b5e 1541 RetCode_t RA8875::filltriangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1542 loc_t x3, loc_t y3, color_t color, fill_t fillit)
WiredHome 73:f22a18707b5e 1543 {
WiredHome 73:f22a18707b5e 1544 RetCode_t ret;
WiredHome 73:f22a18707b5e 1545
WiredHome 73:f22a18707b5e 1546 foreground(color);
WiredHome 73:f22a18707b5e 1547 ret = triangle(x1,y1,x2,y2,x3,y3,fillit);
WiredHome 73:f22a18707b5e 1548 return ret;
WiredHome 73:f22a18707b5e 1549 }
WiredHome 73:f22a18707b5e 1550
WiredHome 73:f22a18707b5e 1551
WiredHome 73:f22a18707b5e 1552 RetCode_t RA8875::triangle(loc_t x1, loc_t y1 ,loc_t x2, loc_t y2,
WiredHome 73:f22a18707b5e 1553 loc_t x3, loc_t y3, fill_t fillit)
WiredHome 19:3f82c1161fd2 1554 {
WiredHome 19:3f82c1161fd2 1555 RetCode_t ret = noerror;
WiredHome 73:f22a18707b5e 1556
WiredHome 19:3f82c1161fd2 1557 PERFORMANCE_RESET;
WiredHome 19:3f82c1161fd2 1558 if (x1 == x2 && y1 == y2 && x1 == x3 && y1 == y3) {
WiredHome 19:3f82c1161fd2 1559 pixel(x1, y1);
WiredHome 19:3f82c1161fd2 1560 } else {
WiredHome 38:38d503b4fad6 1561 WriteCommandW(0x91, x1);
WiredHome 38:38d503b4fad6 1562 WriteCommandW(0x93, y1);
WiredHome 38:38d503b4fad6 1563 WriteCommandW(0x95, x2);
WiredHome 38:38d503b4fad6 1564 WriteCommandW(0x97, y2);
WiredHome 38:38d503b4fad6 1565 WriteCommandW(0xA9, x3);
WiredHome 38:38d503b4fad6 1566 WriteCommandW(0xAB, y3);
WiredHome 19:3f82c1161fd2 1567 unsigned char drawCmd = 0x01; // Triangle
WiredHome 19:3f82c1161fd2 1568 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 1569 drawCmd |= 0x20;
WiredHome 19:3f82c1161fd2 1570 WriteCommand(0x90, drawCmd);
WiredHome 19:3f82c1161fd2 1571 WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
WiredHome 131:5bd6ba2ee4a1 1572 if (!_WaitWhileReg(0x90, 0x80)) {
WiredHome 131:5bd6ba2ee4a1 1573 REGISTERPERFORMANCE(PRF_DRAWTRIANGLE);
WiredHome 131:5bd6ba2ee4a1 1574 return external_abort;
WiredHome 131:5bd6ba2ee4a1 1575 }
WiredHome 19:3f82c1161fd2 1576 }
WiredHome 19:3f82c1161fd2 1577 REGISTERPERFORMANCE(PRF_DRAWTRIANGLE);
WiredHome 19:3f82c1161fd2 1578 return ret;
WiredHome 19:3f82c1161fd2 1579 }
WiredHome 19:3f82c1161fd2 1580
WiredHome 83:7bad0068cca0 1581
WiredHome 83:7bad0068cca0 1582 RetCode_t RA8875::circle(point_t p, dim_t radius,
WiredHome 83:7bad0068cca0 1583 color_t color, fill_t fillit)
WiredHome 83:7bad0068cca0 1584 {
WiredHome 83:7bad0068cca0 1585 foreground(color);
WiredHome 83:7bad0068cca0 1586 return circle(p.x,p.y,radius,fillit);
WiredHome 83:7bad0068cca0 1587 }
WiredHome 83:7bad0068cca0 1588
WiredHome 83:7bad0068cca0 1589
WiredHome 83:7bad0068cca0 1590 RetCode_t RA8875::fillcircle(point_t p, dim_t radius,
WiredHome 83:7bad0068cca0 1591 color_t color, fill_t fillit)
WiredHome 83:7bad0068cca0 1592 {
WiredHome 83:7bad0068cca0 1593 foreground(color);
WiredHome 83:7bad0068cca0 1594 return circle(p.x,p.y,radius,fillit);
WiredHome 83:7bad0068cca0 1595 }
WiredHome 83:7bad0068cca0 1596
WiredHome 83:7bad0068cca0 1597
WiredHome 83:7bad0068cca0 1598 RetCode_t RA8875::circle(point_t p, dim_t radius, fill_t fillit)
WiredHome 83:7bad0068cca0 1599 {
WiredHome 83:7bad0068cca0 1600 return circle(p.x,p.y,radius,fillit);
WiredHome 83:7bad0068cca0 1601 }
WiredHome 83:7bad0068cca0 1602
WiredHome 83:7bad0068cca0 1603
WiredHome 73:f22a18707b5e 1604 RetCode_t RA8875::circle(loc_t x, loc_t y, dim_t radius,
WiredHome 73:f22a18707b5e 1605 color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1606 {
WiredHome 19:3f82c1161fd2 1607 foreground(color);
WiredHome 19:3f82c1161fd2 1608 return circle(x,y,radius,fillit);
WiredHome 19:3f82c1161fd2 1609 }
WiredHome 19:3f82c1161fd2 1610
WiredHome 44:207594dece70 1611
WiredHome 73:f22a18707b5e 1612 RetCode_t RA8875::fillcircle(loc_t x, loc_t y, dim_t radius,
WiredHome 73:f22a18707b5e 1613 color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1614 {
WiredHome 19:3f82c1161fd2 1615 foreground(color);
WiredHome 19:3f82c1161fd2 1616 return circle(x,y,radius,fillit);
WiredHome 19:3f82c1161fd2 1617 }
WiredHome 19:3f82c1161fd2 1618
WiredHome 44:207594dece70 1619
WiredHome 37:f19b7e7449dc 1620 RetCode_t RA8875::circle(loc_t x, loc_t y, dim_t radius, fill_t fillit)
WiredHome 19:3f82c1161fd2 1621 {
WiredHome 19:3f82c1161fd2 1622 RetCode_t ret = noerror;
WiredHome 73:f22a18707b5e 1623
WiredHome 19:3f82c1161fd2 1624 PERFORMANCE_RESET;
WiredHome 105:4f116006ba1f 1625 if (radius <= 0 || (x - radius) < 0 || (x + radius) > screenwidth
WiredHome 105:4f116006ba1f 1626 || (y - radius) < 0 || (y + radius) > screenheight) {
WiredHome 19:3f82c1161fd2 1627 ret = bad_parameter;
WiredHome 19:3f82c1161fd2 1628 } else if (radius == 1) {
WiredHome 19:3f82c1161fd2 1629 pixel(x,y);
WiredHome 19:3f82c1161fd2 1630 } else {
WiredHome 38:38d503b4fad6 1631 WriteCommandW(0x99, x);
WiredHome 38:38d503b4fad6 1632 WriteCommandW(0x9B, y);
WiredHome 19:3f82c1161fd2 1633 WriteCommand(0x9d, radius & 0xFF);
WiredHome 19:3f82c1161fd2 1634 unsigned char drawCmd = 0x00; // Circle
WiredHome 19:3f82c1161fd2 1635 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 1636 drawCmd |= 0x20;
WiredHome 19:3f82c1161fd2 1637 WriteCommand(0x90, drawCmd);
WiredHome 19:3f82c1161fd2 1638 WriteCommand(0x90, 0x40 + drawCmd); // Start drawing.
WiredHome 131:5bd6ba2ee4a1 1639 if (!_WaitWhileReg(0x90, 0x40)) {
WiredHome 131:5bd6ba2ee4a1 1640 REGISTERPERFORMANCE(PRF_DRAWCIRCLE);
WiredHome 131:5bd6ba2ee4a1 1641 return external_abort;
WiredHome 131:5bd6ba2ee4a1 1642 }
WiredHome 19:3f82c1161fd2 1643 }
WiredHome 19:3f82c1161fd2 1644 REGISTERPERFORMANCE(PRF_DRAWCIRCLE);
WiredHome 19:3f82c1161fd2 1645 return ret;
WiredHome 19:3f82c1161fd2 1646 }
WiredHome 19:3f82c1161fd2 1647
WiredHome 44:207594dece70 1648
WiredHome 37:f19b7e7449dc 1649 RetCode_t RA8875::ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1650 {
WiredHome 19:3f82c1161fd2 1651 foreground(color);
WiredHome 25:9556a3a9b7cc 1652 return ellipse(x,y,radius1,radius2,fillit);
WiredHome 19:3f82c1161fd2 1653 }
WiredHome 19:3f82c1161fd2 1654
WiredHome 44:207594dece70 1655
WiredHome 37:f19b7e7449dc 1656 RetCode_t RA8875::fillellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 25:9556a3a9b7cc 1657 {
WiredHome 25:9556a3a9b7cc 1658 foreground(color);
WiredHome 25:9556a3a9b7cc 1659 return ellipse(x,y,radius1,radius2,fillit);
WiredHome 25:9556a3a9b7cc 1660 }
WiredHome 44:207594dece70 1661
WiredHome 73:f22a18707b5e 1662
WiredHome 37:f19b7e7449dc 1663 RetCode_t RA8875::ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, fill_t fillit)
WiredHome 19:3f82c1161fd2 1664 {
WiredHome 19:3f82c1161fd2 1665 RetCode_t ret = noerror;
WiredHome 73:f22a18707b5e 1666
WiredHome 19:3f82c1161fd2 1667 PERFORMANCE_RESET;
WiredHome 105:4f116006ba1f 1668 if (radius1 <= 0 || radius2 <= 0 || (x - radius1) < 0 || (x + radius1) > screenwidth
WiredHome 105:4f116006ba1f 1669 || (y - radius2) < 0 || (y + radius2) > screenheight) {
WiredHome 85:022bba13c5c4 1670 ret = bad_parameter;
WiredHome 25:9556a3a9b7cc 1671 } else if (radius1 == 1 && radius2 == 1) {
WiredHome 19:3f82c1161fd2 1672 pixel(x, y);
WiredHome 19:3f82c1161fd2 1673 } else {
WiredHome 38:38d503b4fad6 1674 WriteCommandW(0xA5, x);
WiredHome 38:38d503b4fad6 1675 WriteCommandW(0xA7, y);
WiredHome 38:38d503b4fad6 1676 WriteCommandW(0xA1, radius1);
WiredHome 38:38d503b4fad6 1677 WriteCommandW(0xA3, radius2);
WiredHome 19:3f82c1161fd2 1678 unsigned char drawCmd = 0x00; // Ellipse
WiredHome 19:3f82c1161fd2 1679 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 1680 drawCmd |= 0x40;
WiredHome 19:3f82c1161fd2 1681 WriteCommand(0xA0, drawCmd);
WiredHome 19:3f82c1161fd2 1682 WriteCommand(0xA0, 0x80 + drawCmd); // Start drawing.
WiredHome 131:5bd6ba2ee4a1 1683 if (!_WaitWhileReg(0xA0, 0x80)) {
WiredHome 131:5bd6ba2ee4a1 1684 REGISTERPERFORMANCE(PRF_DRAWELLIPSE);
WiredHome 131:5bd6ba2ee4a1 1685 return external_abort;
WiredHome 131:5bd6ba2ee4a1 1686 }
WiredHome 19:3f82c1161fd2 1687 }
WiredHome 19:3f82c1161fd2 1688 REGISTERPERFORMANCE(PRF_DRAWELLIPSE);
WiredHome 19:3f82c1161fd2 1689 return ret;
WiredHome 19:3f82c1161fd2 1690 }
WiredHome 19:3f82c1161fd2 1691
WiredHome 44:207594dece70 1692
WiredHome 68:ab08efabfc88 1693 RetCode_t RA8875::frequency(unsigned long Hz, unsigned long Hz2)
WiredHome 19:3f82c1161fd2 1694 {
WiredHome 66:468a11f05580 1695 spiwritefreq = Hz;
WiredHome 68:ab08efabfc88 1696 if (Hz2 != 0)
WiredHome 68:ab08efabfc88 1697 spireadfreq = Hz2;
WiredHome 68:ab08efabfc88 1698 else
WiredHome 68:ab08efabfc88 1699 spireadfreq = Hz/2;
WiredHome 68:ab08efabfc88 1700 _setWriteSpeed(true);
WiredHome 19:3f82c1161fd2 1701 // __ ___
WiredHome 19:3f82c1161fd2 1702 // Clock ___A Rising edge latched
WiredHome 19:3f82c1161fd2 1703 // ___ ____
WiredHome 19:3f82c1161fd2 1704 // Data ___X____
WiredHome 19:3f82c1161fd2 1705 spi.format(8, 3); // 8 bits and clock to data phase 0
WiredHome 19:3f82c1161fd2 1706 return noerror;
WiredHome 19:3f82c1161fd2 1707 }
WiredHome 19:3f82c1161fd2 1708
WiredHome 68:ab08efabfc88 1709 void RA8875::_setWriteSpeed(bool writeSpeed)
WiredHome 68:ab08efabfc88 1710 {
WiredHome 68:ab08efabfc88 1711 if (writeSpeed) {
WiredHome 68:ab08efabfc88 1712 spi.frequency(spiwritefreq);
WiredHome 68:ab08efabfc88 1713 spiWriteSpeed = true;
WiredHome 68:ab08efabfc88 1714 } else {
WiredHome 68:ab08efabfc88 1715 spi.frequency(spireadfreq);
WiredHome 68:ab08efabfc88 1716 spiWriteSpeed = false;
WiredHome 68:ab08efabfc88 1717 }
WiredHome 68:ab08efabfc88 1718 }
WiredHome 44:207594dece70 1719
WiredHome 131:5bd6ba2ee4a1 1720
WiredHome 131:5bd6ba2ee4a1 1721
WiredHome 131:5bd6ba2ee4a1 1722 RetCode_t RA8875::BlockMove(uint8_t dstLayer, uint8_t dstDataSelect, point_t dstPoint,
WiredHome 131:5bd6ba2ee4a1 1723 uint8_t srcLayer, uint8_t srcDataSelect, point_t srcPoint,
WiredHome 131:5bd6ba2ee4a1 1724 uint16_t bte_width, uint16_t bte_height,
WiredHome 131:5bd6ba2ee4a1 1725 uint8_t bte_op_code, uint8_t bte_rop_code)
WiredHome 131:5bd6ba2ee4a1 1726 {
WiredHome 131:5bd6ba2ee4a1 1727 uint8_t cmd;
WiredHome 131:5bd6ba2ee4a1 1728
WiredHome 131:5bd6ba2ee4a1 1729 PERFORMANCE_RESET;
WiredHome 131:5bd6ba2ee4a1 1730 srcPoint.x &= 0x3FF; // prevent high bits from doing unexpected things
WiredHome 131:5bd6ba2ee4a1 1731 srcPoint.y &= 0x1FF;
WiredHome 131:5bd6ba2ee4a1 1732 dstPoint.x &= 0x3FF;
WiredHome 131:5bd6ba2ee4a1 1733 dstPoint.y &= 0x1FF;
WiredHome 131:5bd6ba2ee4a1 1734 WriteCommandW(0x54, srcPoint.x);
WiredHome 131:5bd6ba2ee4a1 1735 WriteCommandW(0x56, ((srcLayer & 1) << 7) | srcPoint.y);
WiredHome 131:5bd6ba2ee4a1 1736 WriteCommandW(0x58, dstPoint.x);
WiredHome 131:5bd6ba2ee4a1 1737 WriteCommandW(0x5A, ((dstLayer & 1) << 7) | dstPoint.y);
WiredHome 131:5bd6ba2ee4a1 1738 WriteCommandW(0x5C, bte_width);
WiredHome 131:5bd6ba2ee4a1 1739 WriteCommandW(0x5E, bte_height);
WiredHome 131:5bd6ba2ee4a1 1740 WriteCommand(0x51, ((bte_rop_code & 0x0F) << 4) | (bte_op_code & 0x0F));
WiredHome 131:5bd6ba2ee4a1 1741 cmd = ((srcDataSelect & 1) << 6) | ((dstDataSelect & 1) << 5);
WiredHome 131:5bd6ba2ee4a1 1742 WriteCommand(0x50, 0x80 | cmd); // enable the BTE
WiredHome 131:5bd6ba2ee4a1 1743 if (!_WaitWhileBusy(0x40)) {
WiredHome 131:5bd6ba2ee4a1 1744 REGISTERPERFORMANCE(PRF_BLOCKMOVE);
WiredHome 131:5bd6ba2ee4a1 1745 return external_abort;
WiredHome 131:5bd6ba2ee4a1 1746 }
WiredHome 131:5bd6ba2ee4a1 1747 REGISTERPERFORMANCE(PRF_BLOCKMOVE);
WiredHome 131:5bd6ba2ee4a1 1748 return noerror;
WiredHome 131:5bd6ba2ee4a1 1749 }
WiredHome 131:5bd6ba2ee4a1 1750
WiredHome 131:5bd6ba2ee4a1 1751
WiredHome 19:3f82c1161fd2 1752 RetCode_t RA8875::Power(bool on)
WiredHome 19:3f82c1161fd2 1753 {
WiredHome 19:3f82c1161fd2 1754 WriteCommand(0x01, (on) ? 0x80 : 0x00);
WiredHome 19:3f82c1161fd2 1755 return noerror;
WiredHome 19:3f82c1161fd2 1756 }
WiredHome 19:3f82c1161fd2 1757
WiredHome 44:207594dece70 1758
WiredHome 131:5bd6ba2ee4a1 1759 RetCode_t RA8875::Backlight_u8(uint8_t brightness)
WiredHome 19:3f82c1161fd2 1760 {
WiredHome 19:3f82c1161fd2 1761 static bool is_enabled = false;
WiredHome 131:5bd6ba2ee4a1 1762
WiredHome 19:3f82c1161fd2 1763 if (brightness == 0) {
WiredHome 19:3f82c1161fd2 1764 WriteCommand(0x8a); // Disable the PWM
WiredHome 19:3f82c1161fd2 1765 WriteData(0x00);
WiredHome 19:3f82c1161fd2 1766 is_enabled = false;
WiredHome 19:3f82c1161fd2 1767 } else if (!is_enabled) {
WiredHome 19:3f82c1161fd2 1768 WriteCommand(0x8a); // Enable the PWM
WiredHome 19:3f82c1161fd2 1769 WriteData(0x80);
WiredHome 19:3f82c1161fd2 1770 WriteCommand(0x8a); // Not sure why this is needed, but following the pattern
WiredHome 19:3f82c1161fd2 1771 WriteData(0x81); // open PWM (SYS_CLK / 2 as best I can tell)
WiredHome 19:3f82c1161fd2 1772 is_enabled = true;
WiredHome 19:3f82c1161fd2 1773 }
WiredHome 19:3f82c1161fd2 1774 WriteCommand(0x8b, brightness); // Brightness parameter 0xff-0x00
WiredHome 19:3f82c1161fd2 1775 return noerror;
WiredHome 19:3f82c1161fd2 1776 }
WiredHome 19:3f82c1161fd2 1777
WiredHome 86:e86b355940f4 1778 uint8_t RA8875::GetBacklight_u8(void)
WiredHome 86:e86b355940f4 1779 {
WiredHome 86:e86b355940f4 1780 return ReadCommand(0x8b);
WiredHome 86:e86b355940f4 1781 }
WiredHome 44:207594dece70 1782
WiredHome 19:3f82c1161fd2 1783 RetCode_t RA8875::Backlight(float brightness)
WiredHome 19:3f82c1161fd2 1784 {
WiredHome 19:3f82c1161fd2 1785 unsigned char b;
WiredHome 73:f22a18707b5e 1786
WiredHome 29:422616aa04bd 1787 if (brightness >= 1.0)
WiredHome 19:3f82c1161fd2 1788 b = 255;
WiredHome 29:422616aa04bd 1789 else if (brightness <= 0.0)
WiredHome 19:3f82c1161fd2 1790 b = 0;
WiredHome 19:3f82c1161fd2 1791 else
WiredHome 19:3f82c1161fd2 1792 b = (unsigned char)(brightness * 255);
WiredHome 19:3f82c1161fd2 1793 return Backlight_u8(b);
WiredHome 19:3f82c1161fd2 1794 }
WiredHome 19:3f82c1161fd2 1795
WiredHome 86:e86b355940f4 1796 float RA8875::GetBacklight(void)
WiredHome 86:e86b355940f4 1797 {
WiredHome 86:e86b355940f4 1798 return (float)(GetBacklight_u8())/255;
WiredHome 86:e86b355940f4 1799 }
WiredHome 44:207594dece70 1800
WiredHome 98:ecebed9b80b2 1801 RetCode_t RA8875::SelectUserFont(const uint8_t * _font)
WiredHome 98:ecebed9b80b2 1802 {
WiredHome 98:ecebed9b80b2 1803 INFO("Cursor(%d,%d) %p", cursor_x, cursor_y, _font);
WiredHome 98:ecebed9b80b2 1804 INFO("Text C(%d,%d)", GetTextCursor_X(), GetTextCursor_Y());
WiredHome 98:ecebed9b80b2 1805 if (_font) {
WiredHome 98:ecebed9b80b2 1806 HexDump("Font Memory", _font, 16);
WiredHome 98:ecebed9b80b2 1807 extFontHeight = _font[6];
WiredHome 98:ecebed9b80b2 1808 uint32_t totalWidth = 0;
WiredHome 98:ecebed9b80b2 1809 uint16_t firstChar = _font[3] * 256 + _font[2];
WiredHome 98:ecebed9b80b2 1810 uint16_t lastChar = _font[5] * 256 + _font[4];
WiredHome 98:ecebed9b80b2 1811 uint16_t i;
WiredHome 98:ecebed9b80b2 1812
WiredHome 98:ecebed9b80b2 1813 for (i=firstChar; i<=lastChar; i++) {
WiredHome 98:ecebed9b80b2 1814 // 8 bytes of preamble to the first level lookup table
WiredHome 98:ecebed9b80b2 1815 uint16_t offsetToCharLookup = 8 + 4 * (i - firstChar); // 4-bytes: width(pixels), 16-bit offset from table start, 0
WiredHome 98:ecebed9b80b2 1816 totalWidth += _font[offsetToCharLookup];
WiredHome 98:ecebed9b80b2 1817 }
WiredHome 98:ecebed9b80b2 1818 extFontWidth = totalWidth / (lastChar - firstChar);
WiredHome 98:ecebed9b80b2 1819 INFO("Font Metrics: Avg W: %2d, H: %2d, First:%d, Last:%d", extFontWidth, extFontHeight, firstChar, lastChar);
WiredHome 98:ecebed9b80b2 1820 }
WiredHome 98:ecebed9b80b2 1821 SetTextCursor(GetTextCursor_X(), GetTextCursor_Y()); // soft-font cursor -> hw cursor
WiredHome 98:ecebed9b80b2 1822 font = _font;
WiredHome 98:ecebed9b80b2 1823 return GraphicsDisplay::SelectUserFont(_font);
WiredHome 98:ecebed9b80b2 1824 }
WiredHome 44:207594dece70 1825
WiredHome 19:3f82c1161fd2 1826 RetCode_t RA8875::background(color_t color)
WiredHome 19:3f82c1161fd2 1827 {
WiredHome 37:f19b7e7449dc 1828 GraphicsDisplay::background(color);
WiredHome 133:e36dcfc2d756 1829 return _writeColorTrio(0x60, color);
WiredHome 19:3f82c1161fd2 1830 }
WiredHome 19:3f82c1161fd2 1831
WiredHome 44:207594dece70 1832
WiredHome 19:3f82c1161fd2 1833 RetCode_t RA8875::background(unsigned char r, unsigned char g, unsigned char b)
WiredHome 19:3f82c1161fd2 1834 {
WiredHome 37:f19b7e7449dc 1835 background(RGB(r,g,b));
WiredHome 19:3f82c1161fd2 1836 return noerror;
WiredHome 19:3f82c1161fd2 1837 }
WiredHome 19:3f82c1161fd2 1838
WiredHome 44:207594dece70 1839
WiredHome 19:3f82c1161fd2 1840 RetCode_t RA8875::foreground(color_t color)
WiredHome 19:3f82c1161fd2 1841 {
WiredHome 37:f19b7e7449dc 1842 GraphicsDisplay::foreground(color);
WiredHome 133:e36dcfc2d756 1843 return _writeColorTrio(0x63, color);
WiredHome 19:3f82c1161fd2 1844 }
WiredHome 19:3f82c1161fd2 1845
WiredHome 44:207594dece70 1846
WiredHome 37:f19b7e7449dc 1847 RetCode_t RA8875::foreground(unsigned char r, unsigned char g, unsigned char b)
WiredHome 19:3f82c1161fd2 1848 {
WiredHome 37:f19b7e7449dc 1849 foreground(RGB(r,g,b));
WiredHome 19:3f82c1161fd2 1850 return noerror;
WiredHome 19:3f82c1161fd2 1851 }
WiredHome 19:3f82c1161fd2 1852
WiredHome 44:207594dece70 1853
WiredHome 37:f19b7e7449dc 1854 color_t RA8875::GetForeColor(void)
WiredHome 19:3f82c1161fd2 1855 {
WiredHome 133:e36dcfc2d756 1856 return _readColorTrio(0x63);
WiredHome 19:3f82c1161fd2 1857 }
WiredHome 19:3f82c1161fd2 1858
WiredHome 44:207594dece70 1859
WiredHome 19:3f82c1161fd2 1860 color_t RA8875::DOSColor(int i)
WiredHome 73:f22a18707b5e 1861 {
WiredHome 73:f22a18707b5e 1862 const color_t colors[16] = {
WiredHome 19:3f82c1161fd2 1863 Black, Blue, Green, Cyan,
WiredHome 19:3f82c1161fd2 1864 Red, Magenta, Brown, Gray,
WiredHome 19:3f82c1161fd2 1865 Charcoal, BrightBlue, BrightGreen, BrightCyan,
WiredHome 19:3f82c1161fd2 1866 Orange, Pink, Yellow, White
WiredHome 73:f22a18707b5e 1867 };
WiredHome 85:022bba13c5c4 1868 if (i >= 0 && i < 16)
WiredHome 19:3f82c1161fd2 1869 return colors[i];
WiredHome 19:3f82c1161fd2 1870 else
WiredHome 19:3f82c1161fd2 1871 return 0;
WiredHome 73:f22a18707b5e 1872 }
WiredHome 19:3f82c1161fd2 1873
WiredHome 44:207594dece70 1874
WiredHome 73:f22a18707b5e 1875 const char * RA8875::DOSColorNames(int i)
WiredHome 73:f22a18707b5e 1876 {
WiredHome 73:f22a18707b5e 1877 const char * names[16] = {
WiredHome 19:3f82c1161fd2 1878 "Black", "Blue", "Green", "Cyan",
WiredHome 19:3f82c1161fd2 1879 "Red", "Magenta", "Brown", "Gray",
WiredHome 19:3f82c1161fd2 1880 "Charcoal", "BrightBlue", "BrightGreen", "BrightCyan",
WiredHome 19:3f82c1161fd2 1881 "Orange", "Pink", "Yellow", "White"
WiredHome 73:f22a18707b5e 1882 };
WiredHome 85:022bba13c5c4 1883 if (i >= 0 && i < 16)
WiredHome 19:3f82c1161fd2 1884 return names[i];
WiredHome 19:3f82c1161fd2 1885 else
WiredHome 19:3f82c1161fd2 1886 return NULL;
WiredHome 73:f22a18707b5e 1887 }
WiredHome 19:3f82c1161fd2 1888
WiredHome 19:3f82c1161fd2 1889
WiredHome 19:3f82c1161fd2 1890 ///////////////////////////////////////////////////////////////
WiredHome 19:3f82c1161fd2 1891 // Private functions
WiredHome 19:3f82c1161fd2 1892
WiredHome 79:544eb4964795 1893 unsigned char RA8875::_spiwrite(unsigned char data)
WiredHome 19:3f82c1161fd2 1894 {
WiredHome 19:3f82c1161fd2 1895 unsigned char retval;
WiredHome 73:f22a18707b5e 1896
WiredHome 68:ab08efabfc88 1897 if (!spiWriteSpeed)
WiredHome 68:ab08efabfc88 1898 _setWriteSpeed(true);
WiredHome 19:3f82c1161fd2 1899 retval = spi.write(data);
WiredHome 19:3f82c1161fd2 1900 return retval;
WiredHome 19:3f82c1161fd2 1901 }
WiredHome 19:3f82c1161fd2 1902
WiredHome 44:207594dece70 1903
WiredHome 79:544eb4964795 1904 unsigned char RA8875::_spiread(void)
WiredHome 19:3f82c1161fd2 1905 {
WiredHome 19:3f82c1161fd2 1906 unsigned char retval;
WiredHome 19:3f82c1161fd2 1907 unsigned char data = 0;
WiredHome 73:f22a18707b5e 1908
WiredHome 68:ab08efabfc88 1909 if (spiWriteSpeed)
WiredHome 68:ab08efabfc88 1910 _setWriteSpeed(false);
WiredHome 19:3f82c1161fd2 1911 retval = spi.write(data);
WiredHome 19:3f82c1161fd2 1912 return retval;
WiredHome 19:3f82c1161fd2 1913 }
WiredHome 19:3f82c1161fd2 1914
WiredHome 44:207594dece70 1915
WiredHome 79:544eb4964795 1916 RetCode_t RA8875::_select(bool chipsel)
WiredHome 19:3f82c1161fd2 1917 {
WiredHome 19:3f82c1161fd2 1918 cs = (chipsel == true) ? 0 : 1;
WiredHome 19:3f82c1161fd2 1919 return noerror;
WiredHome 19:3f82c1161fd2 1920 }
WiredHome 19:3f82c1161fd2 1921
WiredHome 44:207594dece70 1922
WiredHome 72:ecffe56af969 1923 RetCode_t RA8875::PrintScreen(uint16_t layer, loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP)
WiredHome 72:ecffe56af969 1924 {
WiredHome 74:686faa218914 1925 (void)layer;
WiredHome 96:40b74dd3695b 1926
WiredHome 96:40b74dd3695b 1927 // AttachPrintHandler(this, RA8875::_printCallback);
WiredHome 96:40b74dd3695b 1928 // return PrintScreen(x,y,w,h);
WiredHome 74:686faa218914 1929 return PrintScreen(x, y, w, h, Name_BMP);
WiredHome 72:ecffe56af969 1930 }
WiredHome 72:ecffe56af969 1931
WiredHome 96:40b74dd3695b 1932 RetCode_t RA8875::_printCallback(RA8875::filecmd_t cmd, uint8_t * buffer, uint16_t size)
WiredHome 96:40b74dd3695b 1933 {
WiredHome 96:40b74dd3695b 1934 HexDump("CB", buffer, size);
WiredHome 96:40b74dd3695b 1935 switch(cmd) {
WiredHome 96:40b74dd3695b 1936 case RA8875::OPEN:
WiredHome 96:40b74dd3695b 1937 //pc.printf("About to write %lu bytes\r\n", *(uint32_t *)buffer);
WiredHome 96:40b74dd3695b 1938 _printFH = fopen("file.bmp", "w+b");
WiredHome 96:40b74dd3695b 1939 if (_printFH == 0)
WiredHome 96:40b74dd3695b 1940 return file_not_found;
WiredHome 96:40b74dd3695b 1941 break;
WiredHome 96:40b74dd3695b 1942 case RA8875::WRITE:
WiredHome 96:40b74dd3695b 1943 //pc.printf(" Write %4u bytes\r\n", size);
WiredHome 96:40b74dd3695b 1944 fwrite(buffer, 1, size, _printFH);
WiredHome 96:40b74dd3695b 1945 break;
WiredHome 96:40b74dd3695b 1946 case RA8875::CLOSE:
WiredHome 96:40b74dd3695b 1947 //pc.printf(" close\r\n");
WiredHome 96:40b74dd3695b 1948 fclose(_printFH);
WiredHome 96:40b74dd3695b 1949 _printFH = 0;
WiredHome 96:40b74dd3695b 1950 break;
WiredHome 96:40b74dd3695b 1951 default:
WiredHome 96:40b74dd3695b 1952 //pc.printf("Unexpected callback %d\r\n", cmd);
WiredHome 96:40b74dd3695b 1953 return file_not_found;
WiredHome 96:40b74dd3695b 1954 //break;
WiredHome 96:40b74dd3695b 1955 }
WiredHome 96:40b74dd3695b 1956 return noerror;
WiredHome 96:40b74dd3695b 1957 }
WiredHome 96:40b74dd3695b 1958
WiredHome 96:40b74dd3695b 1959 RetCode_t RA8875::PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h)
WiredHome 96:40b74dd3695b 1960 {
WiredHome 96:40b74dd3695b 1961 BITMAPFILEHEADER BMP_Header;
WiredHome 96:40b74dd3695b 1962 BITMAPINFOHEADER BMP_Info;
WiredHome 96:40b74dd3695b 1963 uint8_t * lineBuffer = NULL;
WiredHome 96:40b74dd3695b 1964 color_t * pixelBuffer = NULL;
WiredHome 96:40b74dd3695b 1965 color_t * pixelBuffer2 = NULL;
WiredHome 96:40b74dd3695b 1966
WiredHome 98:ecebed9b80b2 1967 INFO("(%d,%d) - (%d,%d)", x,y,w,h);
WiredHome 105:4f116006ba1f 1968 if (x >= 0 && x < screenwidth
WiredHome 105:4f116006ba1f 1969 && y >= 0 && y < screenheight
WiredHome 105:4f116006ba1f 1970 && w > 0 && x + w <= screenwidth
WiredHome 105:4f116006ba1f 1971 && h > 0 && y + h <= screenheight) {
WiredHome 96:40b74dd3695b 1972
WiredHome 96:40b74dd3695b 1973 BMP_Header.bfType = BF_TYPE;
WiredHome 96:40b74dd3695b 1974 BMP_Header.bfSize = (w * h * sizeof(RGBQUAD)) + sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 96:40b74dd3695b 1975 BMP_Header.bfReserved1 = 0;
WiredHome 96:40b74dd3695b 1976 BMP_Header.bfReserved2 = 0;
WiredHome 96:40b74dd3695b 1977 BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 96:40b74dd3695b 1978
WiredHome 96:40b74dd3695b 1979 BMP_Info.biSize = sizeof(BMP_Info);
WiredHome 96:40b74dd3695b 1980 BMP_Info.biWidth = w;
WiredHome 96:40b74dd3695b 1981 BMP_Info.biHeight = h;
WiredHome 96:40b74dd3695b 1982 BMP_Info.biPlanes = 1;
WiredHome 96:40b74dd3695b 1983 BMP_Info.biBitCount = 24;
WiredHome 96:40b74dd3695b 1984 BMP_Info.biCompression = BI_RGB;
WiredHome 96:40b74dd3695b 1985 BMP_Info.biSizeImage = 0;
WiredHome 96:40b74dd3695b 1986 BMP_Info.biXPelsPerMeter = 0;
WiredHome 96:40b74dd3695b 1987 BMP_Info.biYPelsPerMeter = 0;
WiredHome 96:40b74dd3695b 1988 BMP_Info.biClrUsed = 0;
WiredHome 96:40b74dd3695b 1989 BMP_Info.biClrImportant = 0;
WiredHome 96:40b74dd3695b 1990
WiredHome 96:40b74dd3695b 1991 // Allocate the memory we need to proceed
WiredHome 96:40b74dd3695b 1992 int lineBufSize = ((24 * w + 7)/8);
WiredHome 96:40b74dd3695b 1993 lineBuffer = (uint8_t *)malloc(lineBufSize);
WiredHome 96:40b74dd3695b 1994 if (lineBuffer == NULL) {
WiredHome 96:40b74dd3695b 1995 ERR("Not enough RAM for PrintScreen lineBuffer");
WiredHome 96:40b74dd3695b 1996 return(not_enough_ram);
WiredHome 96:40b74dd3695b 1997 }
WiredHome 96:40b74dd3695b 1998
WiredHome 96:40b74dd3695b 1999 #define DOUBLEBUF /* one larger buffer instead of two */
WiredHome 96:40b74dd3695b 2000
WiredHome 96:40b74dd3695b 2001 #ifdef DOUBLEBUF
WiredHome 96:40b74dd3695b 2002 // In the "#else", pixelBuffer2 malloc returns a value,
WiredHome 96:40b74dd3695b 2003 // but is actually causing a failure later.
WiredHome 96:40b74dd3695b 2004 // This test helps determine if it is truly out of memory,
WiredHome 96:40b74dd3695b 2005 // or if malloc is broken.
WiredHome 96:40b74dd3695b 2006 pixelBuffer = (color_t *)malloc(2 * w * sizeof(color_t));
WiredHome 96:40b74dd3695b 2007 pixelBuffer2 = pixelBuffer + (w * sizeof(color_t));
WiredHome 96:40b74dd3695b 2008 #else
WiredHome 96:40b74dd3695b 2009 pixelBuffer = (color_t *)malloc(w * sizeof(color_t));
WiredHome 96:40b74dd3695b 2010 pixelBuffer2 = (color_t *)malloc(w * sizeof(color_t));
WiredHome 96:40b74dd3695b 2011 #endif
WiredHome 96:40b74dd3695b 2012 if (pixelBuffer == NULL || pixelBuffer2 == NULL) {
WiredHome 96:40b74dd3695b 2013 ERR("Not enough RAM for pixelBuffer");
WiredHome 96:40b74dd3695b 2014 #ifndef DOUBLEBUF
WiredHome 96:40b74dd3695b 2015 if (pixelBuffer2)
WiredHome 96:40b74dd3695b 2016 free(pixelBuffer2);
WiredHome 96:40b74dd3695b 2017 #endif
WiredHome 96:40b74dd3695b 2018 if (pixelBuffer)
WiredHome 96:40b74dd3695b 2019 free(pixelBuffer);
WiredHome 96:40b74dd3695b 2020 free(lineBuffer);
WiredHome 96:40b74dd3695b 2021 return(not_enough_ram);
WiredHome 96:40b74dd3695b 2022 }
WiredHome 96:40b74dd3695b 2023
WiredHome 96:40b74dd3695b 2024 // Get the file primed...
WiredHome 96:40b74dd3695b 2025 privateCallback(OPEN, (uint8_t *)&BMP_Header.bfSize, 4);
WiredHome 96:40b74dd3695b 2026
WiredHome 96:40b74dd3695b 2027 // Be optimistic - don't check for errors.
WiredHome 96:40b74dd3695b 2028 HexDump("BMP_Header", (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome 96:40b74dd3695b 2029 //fwrite(&BMP_Header, sizeof(char), sizeof(BMP_Header), Image);
WiredHome 96:40b74dd3695b 2030 privateCallback(WRITE, (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome 96:40b74dd3695b 2031
WiredHome 96:40b74dd3695b 2032 HexDump("BMP_Info", (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome 96:40b74dd3695b 2033 //fwrite(&BMP_Info, sizeof(char), sizeof(BMP_Info), Image);
WiredHome 96:40b74dd3695b 2034 privateCallback(WRITE, (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome 96:40b74dd3695b 2035
WiredHome 96:40b74dd3695b 2036 //color_t transparency = GetBackgroundTransparencyColor();
WiredHome 96:40b74dd3695b 2037 LayerMode_T ltpr0 = GetLayerMode();
WiredHome 96:40b74dd3695b 2038
WiredHome 96:40b74dd3695b 2039 uint16_t prevLayer = GetDrawingLayer();
WiredHome 96:40b74dd3695b 2040 // If only one of the layers is visible, select that layer
WiredHome 96:40b74dd3695b 2041 switch(ltpr0) {
WiredHome 96:40b74dd3695b 2042 case ShowLayer0:
WiredHome 96:40b74dd3695b 2043 SelectDrawingLayer(0);
WiredHome 96:40b74dd3695b 2044 break;
WiredHome 96:40b74dd3695b 2045 case ShowLayer1:
WiredHome 96:40b74dd3695b 2046 SelectDrawingLayer(1);
WiredHome 96:40b74dd3695b 2047 break;
WiredHome 96:40b74dd3695b 2048 default:
WiredHome 96:40b74dd3695b 2049 break;
WiredHome 96:40b74dd3695b 2050 }
WiredHome 96:40b74dd3695b 2051
WiredHome 96:40b74dd3695b 2052 // Read the display from the last line toward the top
WiredHome 96:40b74dd3695b 2053 // so we can write the file in one pass.
WiredHome 96:40b74dd3695b 2054 for (int j = h - 1; j >= 0; j--) {
WiredHome 96:40b74dd3695b 2055 if (ltpr0 >= 2) // Need to combine the layers...
WiredHome 96:40b74dd3695b 2056 SelectDrawingLayer(0); // so read layer 0 first
WiredHome 96:40b74dd3695b 2057 // Read one line of pixels to a local buffer
WiredHome 96:40b74dd3695b 2058 if (getPixelStream(pixelBuffer, w, x,y+j) != noerror) {
WiredHome 96:40b74dd3695b 2059 ERR("getPixelStream error, and no recovery handler...");
WiredHome 96:40b74dd3695b 2060 }
WiredHome 96:40b74dd3695b 2061 if (ltpr0 >= 2) { // Need to combine the layers...
WiredHome 96:40b74dd3695b 2062 SelectDrawingLayer(1); // so read layer 1 next
WiredHome 96:40b74dd3695b 2063 if (getPixelStream(pixelBuffer2, w, x,y+j) != noerror) {
WiredHome 96:40b74dd3695b 2064 ERR("getPixelStream error, and no recovery handler...");
WiredHome 96:40b74dd3695b 2065 }
WiredHome 96:40b74dd3695b 2066 }
WiredHome 96:40b74dd3695b 2067 INFO("1st Color: %04X", pixelBuffer[0]);
WiredHome 96:40b74dd3695b 2068 HexDump("Raster", (uint8_t *)pixelBuffer, w);
WiredHome 96:40b74dd3695b 2069 // Convert the local buffer to RGBQUAD format
WiredHome 96:40b74dd3695b 2070 int lb = 0;
WiredHome 96:40b74dd3695b 2071 for (int i=0; i<w; i++) {
WiredHome 96:40b74dd3695b 2072 RGBQUAD q0 = RGB16ToRGBQuad(pixelBuffer[x+i]); // Scale to 24-bits
WiredHome 96:40b74dd3695b 2073 RGBQUAD q1 = RGB16ToRGBQuad(pixelBuffer2[x+i]); // Scale to 24-bits
WiredHome 96:40b74dd3695b 2074 switch (ltpr0) {
WiredHome 96:40b74dd3695b 2075 case 0:
WiredHome 96:40b74dd3695b 2076 case 1:
WiredHome 96:40b74dd3695b 2077 case 2: // lighten-overlay (@TODO Not supported yet)
WiredHome 96:40b74dd3695b 2078 case 6: // Floating Windows (@TODO not sure how to support)
WiredHome 96:40b74dd3695b 2079 default: // Reserved...
WiredHome 96:40b74dd3695b 2080 lineBuffer[lb++] = q0.rgbBlue;
WiredHome 96:40b74dd3695b 2081 lineBuffer[lb++] = q0.rgbGreen;
WiredHome 96:40b74dd3695b 2082 lineBuffer[lb++] = q0.rgbRed;
WiredHome 96:40b74dd3695b 2083 break;
WiredHome 96:40b74dd3695b 2084 case 3: // transparent mode (@TODO Read the background color register for transparent)
WiredHome 96:40b74dd3695b 2085 case 4: // boolean or
WiredHome 96:40b74dd3695b 2086 lineBuffer[lb++] = q0.rgbBlue | q1.rgbBlue;
WiredHome 96:40b74dd3695b 2087 lineBuffer[lb++] = q0.rgbGreen | q1.rgbGreen;
WiredHome 96:40b74dd3695b 2088 lineBuffer[lb++] = q0.rgbRed | q1.rgbRed;
WiredHome 96:40b74dd3695b 2089 break;
WiredHome 96:40b74dd3695b 2090 case 5: // boolean AND
WiredHome 96:40b74dd3695b 2091 lineBuffer[lb++] = q0.rgbBlue & q1.rgbBlue;
WiredHome 96:40b74dd3695b 2092 lineBuffer[lb++] = q0.rgbGreen & q1.rgbGreen;
WiredHome 96:40b74dd3695b 2093 lineBuffer[lb++] = q0.rgbRed & q1.rgbRed;
WiredHome 96:40b74dd3695b 2094 break;
WiredHome 96:40b74dd3695b 2095 }
WiredHome 96:40b74dd3695b 2096 }
WiredHome 96:40b74dd3695b 2097 if (j == h - 1) {
WiredHome 96:40b74dd3695b 2098 HexDump("Line", lineBuffer, lineBufSize);
WiredHome 96:40b74dd3695b 2099 }
WiredHome 96:40b74dd3695b 2100 // Write to disk
WiredHome 96:40b74dd3695b 2101 //fwrite(lineBuffer, sizeof(char), lb, Image);
WiredHome 96:40b74dd3695b 2102 privateCallback(WRITE, (uint8_t *)lineBuffer, lb);
WiredHome 96:40b74dd3695b 2103 }
WiredHome 96:40b74dd3695b 2104 SelectDrawingLayer(prevLayer);
WiredHome 96:40b74dd3695b 2105 //fclose(Image);
WiredHome 96:40b74dd3695b 2106 privateCallback(CLOSE, NULL, 0);
WiredHome 96:40b74dd3695b 2107
WiredHome 96:40b74dd3695b 2108 #ifndef DOUBLEBUF
WiredHome 96:40b74dd3695b 2109 if (pixelBuffer2)
WiredHome 96:40b74dd3695b 2110 free(pixelBuffer2);
WiredHome 96:40b74dd3695b 2111 #endif
WiredHome 96:40b74dd3695b 2112 if (pixelBuffer)
WiredHome 96:40b74dd3695b 2113 free(pixelBuffer);
WiredHome 96:40b74dd3695b 2114 free(lineBuffer);
WiredHome 96:40b74dd3695b 2115 INFO("Image closed");
WiredHome 96:40b74dd3695b 2116 return noerror;
WiredHome 96:40b74dd3695b 2117 } else {
WiredHome 96:40b74dd3695b 2118 return bad_parameter;
WiredHome 96:40b74dd3695b 2119 }
WiredHome 96:40b74dd3695b 2120 }
WiredHome 79:544eb4964795 2121
WiredHome 72:ecffe56af969 2122 RetCode_t RA8875::PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP)
WiredHome 72:ecffe56af969 2123 {
WiredHome 72:ecffe56af969 2124 BITMAPFILEHEADER BMP_Header;
WiredHome 72:ecffe56af969 2125 BITMAPINFOHEADER BMP_Info;
WiredHome 86:e86b355940f4 2126 uint8_t * lineBuffer = NULL;
WiredHome 86:e86b355940f4 2127 color_t * pixelBuffer = NULL;
WiredHome 86:e86b355940f4 2128 color_t * pixelBuffer2 = NULL;
WiredHome 86:e86b355940f4 2129
WiredHome 72:ecffe56af969 2130 INFO("(%d,%d) - (%d,%d) %s", x,y,w,h,Name_BMP);
WiredHome 105:4f116006ba1f 2131 if (x >= 0 && x < screenwidth
WiredHome 105:4f116006ba1f 2132 && y >= 0 && y < screenheight
WiredHome 105:4f116006ba1f 2133 && w > 0 && x + w <= screenwidth
WiredHome 105:4f116006ba1f 2134 && h > 0 && y + h <= screenheight) {
WiredHome 72:ecffe56af969 2135
WiredHome 72:ecffe56af969 2136 BMP_Header.bfType = BF_TYPE;
WiredHome 72:ecffe56af969 2137 BMP_Header.bfSize = (w * h * sizeof(RGBQUAD)) + sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 72:ecffe56af969 2138 BMP_Header.bfReserved1 = 0;
WiredHome 72:ecffe56af969 2139 BMP_Header.bfReserved2 = 0;
WiredHome 72:ecffe56af969 2140 BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 73:f22a18707b5e 2141
WiredHome 72:ecffe56af969 2142 BMP_Info.biSize = sizeof(BMP_Info);
WiredHome 72:ecffe56af969 2143 BMP_Info.biWidth = w;
WiredHome 72:ecffe56af969 2144 BMP_Info.biHeight = h;
WiredHome 72:ecffe56af969 2145 BMP_Info.biPlanes = 1;
WiredHome 72:ecffe56af969 2146 BMP_Info.biBitCount = 24;
WiredHome 72:ecffe56af969 2147 BMP_Info.biCompression = BI_RGB;
WiredHome 72:ecffe56af969 2148 BMP_Info.biSizeImage = 0;
WiredHome 72:ecffe56af969 2149 BMP_Info.biXPelsPerMeter = 0;
WiredHome 72:ecffe56af969 2150 BMP_Info.biYPelsPerMeter = 0;
WiredHome 72:ecffe56af969 2151 BMP_Info.biClrUsed = 0;
WiredHome 72:ecffe56af969 2152 BMP_Info.biClrImportant = 0;
WiredHome 72:ecffe56af969 2153
WiredHome 86:e86b355940f4 2154 // Allocate the memory we need to proceed
WiredHome 86:e86b355940f4 2155 int lineBufSize = ((24 * w + 7)/8);
WiredHome 86:e86b355940f4 2156 lineBuffer = (uint8_t *)malloc(lineBufSize);
WiredHome 86:e86b355940f4 2157 if (lineBuffer == NULL) {
WiredHome 86:e86b355940f4 2158 ERR("Not enough RAM for PrintScreen lineBuffer");
WiredHome 86:e86b355940f4 2159 return(not_enough_ram);
WiredHome 86:e86b355940f4 2160 }
WiredHome 86:e86b355940f4 2161
WiredHome 86:e86b355940f4 2162 #define DOUBLEBUF /* one larger buffer instead of two */
WiredHome 86:e86b355940f4 2163
WiredHome 86:e86b355940f4 2164 #ifdef DOUBLEBUF
WiredHome 86:e86b355940f4 2165 // In the "#else", pixelBuffer2 malloc returns a value,
WiredHome 86:e86b355940f4 2166 // but is actually causing a failure later.
WiredHome 86:e86b355940f4 2167 // This test helps determine if it is truly out of memory,
WiredHome 86:e86b355940f4 2168 // or if malloc is broken.
WiredHome 86:e86b355940f4 2169 pixelBuffer = (color_t *)malloc(2 * w * sizeof(color_t));
WiredHome 86:e86b355940f4 2170 pixelBuffer2 = pixelBuffer + (w * sizeof(color_t));
WiredHome 86:e86b355940f4 2171 #else
WiredHome 86:e86b355940f4 2172 pixelBuffer = (color_t *)malloc(w * sizeof(color_t));
WiredHome 86:e86b355940f4 2173 pixelBuffer2 = (color_t *)malloc(w * sizeof(color_t));
WiredHome 86:e86b355940f4 2174 #endif
WiredHome 86:e86b355940f4 2175 if (pixelBuffer == NULL || pixelBuffer2 == NULL) {
WiredHome 86:e86b355940f4 2176 ERR("Not enough RAM for pixelBuffer");
WiredHome 86:e86b355940f4 2177 #ifndef DOUBLEBUF
WiredHome 86:e86b355940f4 2178 if (pixelBuffer2)
WiredHome 86:e86b355940f4 2179 free(pixelBuffer2);
WiredHome 86:e86b355940f4 2180 #endif
WiredHome 86:e86b355940f4 2181 if (pixelBuffer)
WiredHome 86:e86b355940f4 2182 free(pixelBuffer);
WiredHome 86:e86b355940f4 2183 free(lineBuffer);
WiredHome 86:e86b355940f4 2184 return(not_enough_ram);
WiredHome 86:e86b355940f4 2185 }
WiredHome 86:e86b355940f4 2186
WiredHome 72:ecffe56af969 2187 FILE *Image = fopen(Name_BMP, "wb");
WiredHome 72:ecffe56af969 2188 if (!Image) {
WiredHome 86:e86b355940f4 2189 ERR("Can't open file for write");
WiredHome 86:e86b355940f4 2190 #ifndef DOUBLEBUF
WiredHome 86:e86b355940f4 2191 if (pixelBuffer2)
WiredHome 86:e86b355940f4 2192 free(pixelBuffer2);
WiredHome 86:e86b355940f4 2193 #endif
WiredHome 86:e86b355940f4 2194 if (pixelBuffer)
WiredHome 86:e86b355940f4 2195 free(pixelBuffer);
WiredHome 86:e86b355940f4 2196 free(lineBuffer);
WiredHome 72:ecffe56af969 2197 return(file_not_found);
WiredHome 72:ecffe56af969 2198 }
WiredHome 72:ecffe56af969 2199
WiredHome 72:ecffe56af969 2200 // Be optimistic - don't check for errors.
WiredHome 93:6fbc516de05e 2201 HexDump("BMP_Header", (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome 95:ef538bd687c0 2202 fwrite(&BMP_Header, sizeof(char), sizeof(BMP_Header), Image);
WiredHome 73:f22a18707b5e 2203
WiredHome 93:6fbc516de05e 2204 HexDump("BMP_Info", (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome 95:ef538bd687c0 2205 fwrite(&BMP_Info, sizeof(char), sizeof(BMP_Info), Image);
WiredHome 73:f22a18707b5e 2206
WiredHome 95:ef538bd687c0 2207 //color_t transparency = GetBackgroundTransparencyColor();
WiredHome 95:ef538bd687c0 2208 LayerMode_T ltpr0 = GetLayerMode();
WiredHome 73:f22a18707b5e 2209
WiredHome 73:f22a18707b5e 2210 uint16_t prevLayer = GetDrawingLayer();
WiredHome 73:f22a18707b5e 2211 // If only one of the layers is visible, select that layer
WiredHome 73:f22a18707b5e 2212 switch(ltpr0) {
WiredHome 95:ef538bd687c0 2213 case ShowLayer0:
WiredHome 73:f22a18707b5e 2214 SelectDrawingLayer(0);
WiredHome 73:f22a18707b5e 2215 break;
WiredHome 95:ef538bd687c0 2216 case ShowLayer1:
WiredHome 73:f22a18707b5e 2217 SelectDrawingLayer(1);
WiredHome 73:f22a18707b5e 2218 break;
WiredHome 73:f22a18707b5e 2219 default:
WiredHome 73:f22a18707b5e 2220 break;
WiredHome 73:f22a18707b5e 2221 }
WiredHome 73:f22a18707b5e 2222
WiredHome 72:ecffe56af969 2223 // Read the display from the last line toward the top
WiredHome 72:ecffe56af969 2224 // so we can write the file in one pass.
WiredHome 72:ecffe56af969 2225 for (int j = h - 1; j >= 0; j--) {
WiredHome 73:f22a18707b5e 2226 if (ltpr0 >= 2) // Need to combine the layers...
WiredHome 73:f22a18707b5e 2227 SelectDrawingLayer(0); // so read layer 0 first
WiredHome 72:ecffe56af969 2228 // Read one line of pixels to a local buffer
WiredHome 72:ecffe56af969 2229 if (getPixelStream(pixelBuffer, w, x,y+j) != noerror) {
WiredHome 72:ecffe56af969 2230 ERR("getPixelStream error, and no recovery handler...");
WiredHome 72:ecffe56af969 2231 }
WiredHome 73:f22a18707b5e 2232 if (ltpr0 >= 2) { // Need to combine the layers...
WiredHome 86:e86b355940f4 2233 SelectDrawingLayer(1); // so read layer 1 next
WiredHome 73:f22a18707b5e 2234 if (getPixelStream(pixelBuffer2, w, x,y+j) != noerror) {
WiredHome 73:f22a18707b5e 2235 ERR("getPixelStream error, and no recovery handler...");
WiredHome 73:f22a18707b5e 2236 }
WiredHome 73:f22a18707b5e 2237 }
WiredHome 93:6fbc516de05e 2238 INFO("1st Color: %04X", pixelBuffer[0]);
WiredHome 93:6fbc516de05e 2239 HexDump("Raster", (uint8_t *)pixelBuffer, w);
WiredHome 72:ecffe56af969 2240 // Convert the local buffer to RGBQUAD format
WiredHome 72:ecffe56af969 2241 int lb = 0;
WiredHome 72:ecffe56af969 2242 for (int i=0; i<w; i++) {
WiredHome 73:f22a18707b5e 2243 RGBQUAD q0 = RGB16ToRGBQuad(pixelBuffer[x+i]); // Scale to 24-bits
WiredHome 73:f22a18707b5e 2244 RGBQUAD q1 = RGB16ToRGBQuad(pixelBuffer2[x+i]); // Scale to 24-bits
WiredHome 73:f22a18707b5e 2245 switch (ltpr0) {
WiredHome 73:f22a18707b5e 2246 case 0:
WiredHome 73:f22a18707b5e 2247 case 1:
WiredHome 73:f22a18707b5e 2248 case 2: // lighten-overlay (@TODO Not supported yet)
WiredHome 73:f22a18707b5e 2249 case 6: // Floating Windows (@TODO not sure how to support)
WiredHome 73:f22a18707b5e 2250 default: // Reserved...
WiredHome 73:f22a18707b5e 2251 lineBuffer[lb++] = q0.rgbBlue;
WiredHome 73:f22a18707b5e 2252 lineBuffer[lb++] = q0.rgbGreen;
WiredHome 73:f22a18707b5e 2253 lineBuffer[lb++] = q0.rgbRed;
WiredHome 73:f22a18707b5e 2254 break;
WiredHome 73:f22a18707b5e 2255 case 3: // transparent mode (@TODO Read the background color register for transparent)
WiredHome 73:f22a18707b5e 2256 case 4: // boolean or
WiredHome 73:f22a18707b5e 2257 lineBuffer[lb++] = q0.rgbBlue | q1.rgbBlue;
WiredHome 73:f22a18707b5e 2258 lineBuffer[lb++] = q0.rgbGreen | q1.rgbGreen;
WiredHome 73:f22a18707b5e 2259 lineBuffer[lb++] = q0.rgbRed | q1.rgbRed;
WiredHome 73:f22a18707b5e 2260 break;
WiredHome 73:f22a18707b5e 2261 case 5: // boolean AND
WiredHome 73:f22a18707b5e 2262 lineBuffer[lb++] = q0.rgbBlue & q1.rgbBlue;
WiredHome 73:f22a18707b5e 2263 lineBuffer[lb++] = q0.rgbGreen & q1.rgbGreen;
WiredHome 73:f22a18707b5e 2264 lineBuffer[lb++] = q0.rgbRed & q1.rgbRed;
WiredHome 73:f22a18707b5e 2265 break;
WiredHome 73:f22a18707b5e 2266 }
WiredHome 72:ecffe56af969 2267 }
WiredHome 95:ef538bd687c0 2268 if (j == h - 1) {
WiredHome 73:f22a18707b5e 2269 HexDump("Line", lineBuffer, lineBufSize);
WiredHome 95:ef538bd687c0 2270 }
WiredHome 72:ecffe56af969 2271 // Write to disk
WiredHome 72:ecffe56af969 2272 fwrite(lineBuffer, sizeof(char), lb, Image);
WiredHome 72:ecffe56af969 2273 }
WiredHome 73:f22a18707b5e 2274 SelectDrawingLayer(prevLayer);
WiredHome 72:ecffe56af969 2275 fclose(Image);
WiredHome 86:e86b355940f4 2276 #ifndef DOUBLEBUF
WiredHome 86:e86b355940f4 2277 if (pixelBuffer2)
WiredHome 86:e86b355940f4 2278 free(pixelBuffer2);
WiredHome 86:e86b355940f4 2279 #endif
WiredHome 86:e86b355940f4 2280 if (pixelBuffer)
WiredHome 86:e86b355940f4 2281 free(pixelBuffer);
WiredHome 72:ecffe56af969 2282 free(lineBuffer);
WiredHome 73:f22a18707b5e 2283 INFO("Image closed");
WiredHome 72:ecffe56af969 2284 return noerror;
WiredHome 72:ecffe56af969 2285 } else {
WiredHome 72:ecffe56af969 2286 return bad_parameter;
WiredHome 72:ecffe56af969 2287 }
WiredHome 72:ecffe56af969 2288 }
WiredHome 72:ecffe56af969 2289
WiredHome 72:ecffe56af969 2290
WiredHome 72:ecffe56af969 2291 // ##########################################################################
WiredHome 72:ecffe56af969 2292 // ##########################################################################
WiredHome 72:ecffe56af969 2293 // ##########################################################################
WiredHome 72:ecffe56af969 2294
WiredHome 23:a50ded45dbaf 2295 #ifdef TESTENABLE
WiredHome 23:a50ded45dbaf 2296
WiredHome 98:ecebed9b80b2 2297 #include "BPG_Arial08x08.h"
WiredHome 98:ecebed9b80b2 2298 #include "BPG_Arial20x20.h"
WiredHome 37:f19b7e7449dc 2299
WiredHome 23:a50ded45dbaf 2300 // ______________ ______________ ______________ _______________
WiredHome 23:a50ded45dbaf 2301 // /_____ _____/ / ___________/ / ___________/ /_____ ______/
WiredHome 23:a50ded45dbaf 2302 // / / / / / / / /
WiredHome 23:a50ded45dbaf 2303 // / / / /___ / /__________ / /
WiredHome 23:a50ded45dbaf 2304 // / / / ____/ /__________ / / /
WiredHome 23:a50ded45dbaf 2305 // / / / / / / / /
WiredHome 23:a50ded45dbaf 2306 // / / / /__________ ___________/ / / /
WiredHome 23:a50ded45dbaf 2307 // /__/ /_____________/ /_____________/ /__/
WiredHome 23:a50ded45dbaf 2308 //
WiredHome 23:a50ded45dbaf 2309 // Everything from here down is test code.
WiredHome 75:ca78388cfd77 2310 //
WiredHome 41:2956a0a221e5 2311 bool SuppressSlowStuff = false;
WiredHome 23:a50ded45dbaf 2312
WiredHome 49:c5182231d1b9 2313 void TextWrapTest(RA8875 & display, Serial & pc)
WiredHome 49:c5182231d1b9 2314 {
WiredHome 49:c5182231d1b9 2315 if (!SuppressSlowStuff)
WiredHome 49:c5182231d1b9 2316 pc.printf("Text Wrap Test\r\n");
WiredHome 49:c5182231d1b9 2317 display.background(Black);
WiredHome 49:c5182231d1b9 2318 display.foreground(Blue);
WiredHome 49:c5182231d1b9 2319 display.cls();
WiredHome 49:c5182231d1b9 2320 display.Backlight_u8(255);
WiredHome 100:0b084475d5a9 2321 display.puts("Text Wrap Test.\r\n");
WiredHome 52:e6039a823420 2322 for (int i=1; i<60; i++) {
WiredHome 52:e6039a823420 2323 display.printf("L%2d\n", i % 17);
WiredHome 49:c5182231d1b9 2324 if (!SuppressSlowStuff)
WiredHome 52:e6039a823420 2325 wait_ms(100);
WiredHome 49:c5182231d1b9 2326 }
WiredHome 49:c5182231d1b9 2327 if (!SuppressSlowStuff)
WiredHome 49:c5182231d1b9 2328 wait_ms(3000);
WiredHome 49:c5182231d1b9 2329 }
WiredHome 49:c5182231d1b9 2330
WiredHome 75:ca78388cfd77 2331
WiredHome 75:ca78388cfd77 2332 void ShowKey(RA8875 & display, int key)
WiredHome 75:ca78388cfd77 2333 {
WiredHome 75:ca78388cfd77 2334 loc_t col, row;
WiredHome 75:ca78388cfd77 2335 dim_t r1 = 25;
WiredHome 75:ca78388cfd77 2336 color_t color = (key & 0x80) ? Red : Green;
WiredHome 75:ca78388cfd77 2337
WiredHome 75:ca78388cfd77 2338 key &= 0x7F; // remove the long-press flag
WiredHome 75:ca78388cfd77 2339 row = (key - 1) / 5;
WiredHome 75:ca78388cfd77 2340 col = (key - 1) % 5;
WiredHome 75:ca78388cfd77 2341 if (col > 5) col = 5;
WiredHome 75:ca78388cfd77 2342 if (row > 4) row = 4;
WiredHome 75:ca78388cfd77 2343 display.circle(450 - + (2 * r1) * col, 200 - (2 * r1) * row, r1-2, color, FILL);
WiredHome 75:ca78388cfd77 2344 }
WiredHome 75:ca78388cfd77 2345
WiredHome 75:ca78388cfd77 2346 void HideKey(RA8875 & display, int key)
WiredHome 75:ca78388cfd77 2347 {
WiredHome 75:ca78388cfd77 2348 loc_t col, row;
WiredHome 75:ca78388cfd77 2349 dim_t r1 = 25;
WiredHome 75:ca78388cfd77 2350
WiredHome 75:ca78388cfd77 2351 row = (key - 1) / 5;
WiredHome 75:ca78388cfd77 2352 col = (key - 1) % 5;
WiredHome 75:ca78388cfd77 2353 if (col > 5) col = 5;
WiredHome 75:ca78388cfd77 2354 if (row > 4) row = 4;
WiredHome 75:ca78388cfd77 2355 display.background(Black);
WiredHome 75:ca78388cfd77 2356 display.circle(450 - (2 * r1) * col, 200 - (2 * r1) * row, r1-2, Black, FILL);
WiredHome 75:ca78388cfd77 2357 display.circle(450 - (2 * r1) * col, 200 - (2 * r1) * row, r1-2, Blue);
WiredHome 75:ca78388cfd77 2358 }
WiredHome 75:ca78388cfd77 2359
WiredHome 75:ca78388cfd77 2360 void KeyPadTest(RA8875 & display, Serial & pc)
WiredHome 75:ca78388cfd77 2361 {
WiredHome 75:ca78388cfd77 2362 const uint8_t myMap[22] = {
WiredHome 77:9206c13aa527 2363 0,
WiredHome 75:ca78388cfd77 2364 'a', 'b', 'c', 'd', 'e',
WiredHome 75:ca78388cfd77 2365 'f', 'g', 'h', 'i', 'j',
WiredHome 75:ca78388cfd77 2366 'k', 'l', 'm', 'n', 'o',
WiredHome 75:ca78388cfd77 2367 'p', 'q', 'r', 's', 't',
WiredHome 75:ca78388cfd77 2368 'x'
WiredHome 75:ca78388cfd77 2369 };
WiredHome 77:9206c13aa527 2370
WiredHome 75:ca78388cfd77 2371 display.background(Black);
WiredHome 75:ca78388cfd77 2372 display.foreground(Blue);
WiredHome 75:ca78388cfd77 2373 display.cls();
WiredHome 75:ca78388cfd77 2374 display.Backlight_u8(255);
WiredHome 100:0b084475d5a9 2375 display.puts("KeyPad Test. Touch the keypad...");
WiredHome 75:ca78388cfd77 2376 pc.printf("\r\n"
WiredHome 75:ca78388cfd77 2377 "Raw KeyPad Test. Keypad returns the key-number.\r\n"
WiredHome 75:ca78388cfd77 2378 "Press [most] any PC keyboard key to advance to next test.\r\n");
WiredHome 75:ca78388cfd77 2379 RetCode_t ret = display.KeypadInit(true, true, 3, 7, 3);
WiredHome 75:ca78388cfd77 2380 if (ret != noerror)
WiredHome 75:ca78388cfd77 2381 pc.printf("returncode from KeypadInit is %d\r\n", ret);
WiredHome 75:ca78388cfd77 2382 int lastKey = 0;
WiredHome 75:ca78388cfd77 2383 while (!pc.readable()) {
WiredHome 75:ca78388cfd77 2384 if (display.readable()) {
WiredHome 75:ca78388cfd77 2385 int key = display.getc();
WiredHome 75:ca78388cfd77 2386 if (key) {
WiredHome 75:ca78388cfd77 2387 if (((key & 0x7F) != lastKey) && (lastKey != 0))
WiredHome 75:ca78388cfd77 2388 HideKey(display, lastKey);
WiredHome 75:ca78388cfd77 2389 ShowKey(display, key);
WiredHome 75:ca78388cfd77 2390 lastKey = key & 0x7F;
WiredHome 75:ca78388cfd77 2391 } else {
WiredHome 75:ca78388cfd77 2392 // erase the last one
WiredHome 75:ca78388cfd77 2393 if (lastKey)
WiredHome 75:ca78388cfd77 2394 HideKey(display, lastKey);
WiredHome 75:ca78388cfd77 2395 }
WiredHome 75:ca78388cfd77 2396 }
WiredHome 75:ca78388cfd77 2397 }
WiredHome 75:ca78388cfd77 2398 (void)pc.getc();
WiredHome 75:ca78388cfd77 2399 pc.printf("\r\n"
WiredHome 75:ca78388cfd77 2400 "Map KeyPad Test. Keypad returns the remapped key 'a' - 't'.\r\n"
WiredHome 75:ca78388cfd77 2401 "Press [most] any PC keyboard key to advance to exit test.\r\n");
WiredHome 75:ca78388cfd77 2402 display.SetKeyMap(myMap);
WiredHome 75:ca78388cfd77 2403 while (!pc.readable()) {
WiredHome 75:ca78388cfd77 2404 if (display.readable()) {
WiredHome 75:ca78388cfd77 2405 int key = display.getc();
WiredHome 75:ca78388cfd77 2406 bool longPress = key & 0x80;
WiredHome 75:ca78388cfd77 2407 display.SetTextCursor(0, 120);
WiredHome 75:ca78388cfd77 2408 display.printf("Long Press: %d\r\n", longPress);
WiredHome 75:ca78388cfd77 2409 display.printf(" Remapped: %c %02X\r\n", (key) ? key & 0x7F : ' ', key);
WiredHome 75:ca78388cfd77 2410 }
WiredHome 75:ca78388cfd77 2411 }
WiredHome 75:ca78388cfd77 2412 (void)pc.getc();
WiredHome 75:ca78388cfd77 2413 display.SetKeyMap();
WiredHome 75:ca78388cfd77 2414 pc.printf("\r\n");
WiredHome 75:ca78388cfd77 2415 }
WiredHome 75:ca78388cfd77 2416
WiredHome 23:a50ded45dbaf 2417 void TextCursorTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2418 {
WiredHome 75:ca78388cfd77 2419 const char * iCursor = "The I-Beam cursor should be visible for this text.\r\n";
WiredHome 75:ca78388cfd77 2420 const char * uCursor = "The Underscore cursor should be visible for this text.\r\n";
WiredHome 75:ca78388cfd77 2421 const char * bCursor = "The Block cursor should be visible for this text.\r\n";
WiredHome 37:f19b7e7449dc 2422 const char * bbCursor = "The Blinking Block cursor should be visible for this text.\r\n";
WiredHome 23:a50ded45dbaf 2423 const char * p;
WiredHome 100:0b084475d5a9 2424 int delay = 60;
WiredHome 73:f22a18707b5e 2425
WiredHome 41:2956a0a221e5 2426 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2427 pc.printf("Text Cursor Test\r\n");
WiredHome 73:f22a18707b5e 2428 else
WiredHome 41:2956a0a221e5 2429 delay = 0;
WiredHome 23:a50ded45dbaf 2430 display.background(Black);
WiredHome 23:a50ded45dbaf 2431 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2432 display.cls();
WiredHome 25:9556a3a9b7cc 2433 display.Backlight_u8(255);
WiredHome 100:0b084475d5a9 2434 display.puts("Text Cursor Test.");
WiredHome 73:f22a18707b5e 2435
WiredHome 23:a50ded45dbaf 2436 // visible, non-blinking
WiredHome 24:8ca861acf12d 2437 display.SetTextCursor(0,20);
WiredHome 53:86d24b9480b9 2438 display.SetTextCursorControl(RA8875::IBEAM, false);
WiredHome 24:8ca861acf12d 2439 p = iCursor;
WiredHome 23:a50ded45dbaf 2440 while (*p) {
WiredHome 24:8ca861acf12d 2441 display._putc(*p++);
WiredHome 41:2956a0a221e5 2442 wait_ms(delay);
WiredHome 24:8ca861acf12d 2443 }
WiredHome 24:8ca861acf12d 2444
WiredHome 53:86d24b9480b9 2445 display.SetTextCursorControl(RA8875::UNDER, false);
WiredHome 24:8ca861acf12d 2446 p = uCursor;
WiredHome 24:8ca861acf12d 2447 while (*p) {
WiredHome 24:8ca861acf12d 2448 display._putc(*p++);
WiredHome 41:2956a0a221e5 2449 wait_ms(delay);
WiredHome 23:a50ded45dbaf 2450 }
WiredHome 73:f22a18707b5e 2451
WiredHome 53:86d24b9480b9 2452 display.SetTextCursorControl(RA8875::BLOCK, false);
WiredHome 24:8ca861acf12d 2453 p = bCursor;
WiredHome 24:8ca861acf12d 2454 while (*p) {
WiredHome 24:8ca861acf12d 2455 display._putc(*p++);
WiredHome 41:2956a0a221e5 2456 wait_ms(delay);
WiredHome 24:8ca861acf12d 2457 }
WiredHome 24:8ca861acf12d 2458
WiredHome 53:86d24b9480b9 2459 display.SetTextCursorControl(RA8875::BLOCK, true);
WiredHome 24:8ca861acf12d 2460 p = bbCursor;
WiredHome 24:8ca861acf12d 2461 while (*p) {
WiredHome 24:8ca861acf12d 2462 display._putc(*p++);
WiredHome 41:2956a0a221e5 2463 wait_ms(delay);
WiredHome 24:8ca861acf12d 2464 }
WiredHome 41:2956a0a221e5 2465 wait_ms(delay * 20);
WiredHome 53:86d24b9480b9 2466 display.SetTextCursorControl(RA8875::NOCURSOR, false);
WiredHome 23:a50ded45dbaf 2467 }
WiredHome 23:a50ded45dbaf 2468
WiredHome 44:207594dece70 2469
WiredHome 23:a50ded45dbaf 2470 void BacklightTest(RA8875 & display, Serial & pc, float ramptime)
WiredHome 23:a50ded45dbaf 2471 {
WiredHome 29:422616aa04bd 2472 char buf[60];
WiredHome 41:2956a0a221e5 2473 unsigned int w = (ramptime * 1000)/ 256;
WiredHome 41:2956a0a221e5 2474 int delay = 200;
WiredHome 41:2956a0a221e5 2475
WiredHome 41:2956a0a221e5 2476 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2477 pc.printf("Backlight Test - ramp over %f sec.\r\n", ramptime);
WiredHome 41:2956a0a221e5 2478 else {
WiredHome 41:2956a0a221e5 2479 delay = 0;
WiredHome 41:2956a0a221e5 2480 w = 0;
WiredHome 41:2956a0a221e5 2481 }
WiredHome 23:a50ded45dbaf 2482 display.Backlight_u8(0);
WiredHome 29:422616aa04bd 2483 display.background(White);
WiredHome 23:a50ded45dbaf 2484 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2485 display.cls();
WiredHome 100:0b084475d5a9 2486 display.puts("RA8875 Backlight Test - Ramp up.");
WiredHome 41:2956a0a221e5 2487 wait_ms(delay);
WiredHome 38:38d503b4fad6 2488 for (int i=0; i <= 255; i++) {
WiredHome 29:422616aa04bd 2489 sprintf(buf, "%3d, %4d", i, w);
WiredHome 37:f19b7e7449dc 2490 display.puts(100,100,buf);
WiredHome 23:a50ded45dbaf 2491 display.Backlight_u8(i);
WiredHome 29:422616aa04bd 2492 wait_ms(w);
WiredHome 23:a50ded45dbaf 2493 }
WiredHome 23:a50ded45dbaf 2494 }
WiredHome 23:a50ded45dbaf 2495
WiredHome 44:207594dece70 2496
WiredHome 23:a50ded45dbaf 2497 void BacklightTest2(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2498 {
WiredHome 41:2956a0a221e5 2499 int delay = 20;
WiredHome 41:2956a0a221e5 2500
WiredHome 41:2956a0a221e5 2501 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2502 pc.printf("Backlight Test 2\r\n");
WiredHome 41:2956a0a221e5 2503 else
WiredHome 41:2956a0a221e5 2504 delay = 0;
WiredHome 41:2956a0a221e5 2505
WiredHome 23:a50ded45dbaf 2506 // Dim it out at the end of the tests.
WiredHome 37:f19b7e7449dc 2507 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2508 display.puts(0,0, "Ramp Backlight down.");
WiredHome 23:a50ded45dbaf 2509 // Ramp it off
WiredHome 23:a50ded45dbaf 2510 for (int i=255; i != 0; i--) {
WiredHome 23:a50ded45dbaf 2511 display.Backlight_u8(i);
WiredHome 41:2956a0a221e5 2512 wait_ms(delay);
WiredHome 23:a50ded45dbaf 2513 }
WiredHome 23:a50ded45dbaf 2514 display.Backlight_u8(0);
WiredHome 23:a50ded45dbaf 2515 }
WiredHome 23:a50ded45dbaf 2516
WiredHome 44:207594dece70 2517
WiredHome 23:a50ded45dbaf 2518 void ExternalFontTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2519 {
WiredHome 41:2956a0a221e5 2520 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2521 pc.printf("External Font Test\r\n");
WiredHome 23:a50ded45dbaf 2522 display.background(Black);
WiredHome 23:a50ded45dbaf 2523 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2524 display.cls();
WiredHome 100:0b084475d5a9 2525 display.puts("External Font Test.");
WiredHome 23:a50ded45dbaf 2526 display.Backlight(1);
WiredHome 37:f19b7e7449dc 2527
WiredHome 98:ecebed9b80b2 2528 display.SelectUserFont(BPG_Arial08x08);
WiredHome 73:f22a18707b5e 2529 display.puts(0,30, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
WiredHome 37:f19b7e7449dc 2530
WiredHome 98:ecebed9b80b2 2531 display.SelectUserFont(BPG_Arial20x20);
WiredHome 37:f19b7e7449dc 2532 display.puts("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
WiredHome 98:ecebed9b80b2 2533
WiredHome 98:ecebed9b80b2 2534 display.SelectUserFont();
WiredHome 73:f22a18707b5e 2535
WiredHome 37:f19b7e7449dc 2536 display.puts("Normal font again.");
WiredHome 37:f19b7e7449dc 2537 //display.window(0,0, display.width(), display.height());
WiredHome 23:a50ded45dbaf 2538 }
WiredHome 23:a50ded45dbaf 2539
WiredHome 44:207594dece70 2540
WiredHome 23:a50ded45dbaf 2541 void DOSColorTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2542 {
WiredHome 41:2956a0a221e5 2543 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2544 pc.printf("DOS Color Test\r\n");
WiredHome 23:a50ded45dbaf 2545 display.background(Black);
WiredHome 23:a50ded45dbaf 2546 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2547 display.cls();
WiredHome 100:0b084475d5a9 2548 display.puts("DOS Colors - Fore");
WiredHome 23:a50ded45dbaf 2549 display.puts(280,0, "Back");
WiredHome 23:a50ded45dbaf 2550 display.background(Gray);
WiredHome 23:a50ded45dbaf 2551 for (int i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2552 display.foreground(display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2553 display.puts(160, i*16, display.DOSColorNames(i));
WiredHome 23:a50ded45dbaf 2554 display.background(Black);
WiredHome 23:a50ded45dbaf 2555 }
WiredHome 23:a50ded45dbaf 2556 display.foreground(White);
WiredHome 23:a50ded45dbaf 2557 for (int i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2558 display.background(display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2559 display.puts(360, i*16, display.DOSColorNames(i));
WiredHome 23:a50ded45dbaf 2560 display.foreground(White);
WiredHome 23:a50ded45dbaf 2561 }
WiredHome 23:a50ded45dbaf 2562 }
WiredHome 23:a50ded45dbaf 2563
WiredHome 44:207594dece70 2564
WiredHome 23:a50ded45dbaf 2565 void WebColorTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2566 {
WiredHome 41:2956a0a221e5 2567 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2568 pc.printf("Web Color Test\r\n");
WiredHome 23:a50ded45dbaf 2569 display.background(Black);
WiredHome 23:a50ded45dbaf 2570 display.foreground(Blue);
WiredHome 32:0e4f2ae512e2 2571 display.window(0,0, display.width(), display.height());
WiredHome 23:a50ded45dbaf 2572 display.cls();
WiredHome 59:fb40aad4efd4 2573 display.SetTextFontSize(1,1);
WiredHome 59:fb40aad4efd4 2574 display.puts(200,0, "Web Color Test");
WiredHome 59:fb40aad4efd4 2575 display.SetTextCursor(0,0);
WiredHome 59:fb40aad4efd4 2576 display.puts(" ");
WiredHome 59:fb40aad4efd4 2577 for (int i=0; i<16; i++)
WiredHome 59:fb40aad4efd4 2578 display.printf("%X", i&0xF);
WiredHome 59:fb40aad4efd4 2579 display.puts("\r\n0 ");
WiredHome 23:a50ded45dbaf 2580 for (int i=0; i<sizeof(WebColors)/sizeof(WebColors[0]); i++) {
WiredHome 23:a50ded45dbaf 2581 display.background(WebColors[i]);
WiredHome 23:a50ded45dbaf 2582 display.puts(" ");
WiredHome 59:fb40aad4efd4 2583 if (i % 16 == 15 && i < 255) {
WiredHome 59:fb40aad4efd4 2584 display.printf("\r\n%X ", ((i+1)/16));
WiredHome 59:fb40aad4efd4 2585 }
WiredHome 23:a50ded45dbaf 2586 }
WiredHome 23:a50ded45dbaf 2587 display.SetTextFontSize(1,1);
WiredHome 23:a50ded45dbaf 2588 }
WiredHome 23:a50ded45dbaf 2589
WiredHome 44:207594dece70 2590
WiredHome 37:f19b7e7449dc 2591 void PixelTest(RA8875 & display, Serial & pc)
WiredHome 37:f19b7e7449dc 2592 {
WiredHome 37:f19b7e7449dc 2593 int i, c, x, y;
WiredHome 37:f19b7e7449dc 2594
WiredHome 41:2956a0a221e5 2595 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2596 pc.printf("Pixel Test\r\n");
WiredHome 37:f19b7e7449dc 2597 display.background(Black);
WiredHome 37:f19b7e7449dc 2598 display.foreground(Blue);
WiredHome 37:f19b7e7449dc 2599 display.cls();
WiredHome 100:0b084475d5a9 2600 display.puts("Pixel Test");
WiredHome 37:f19b7e7449dc 2601 for (i=0; i<1000; i++) {
WiredHome 37:f19b7e7449dc 2602 x = rand() % 480;
WiredHome 37:f19b7e7449dc 2603 y = 16 + rand() % (272-16);
WiredHome 37:f19b7e7449dc 2604 c = rand() % 16;
WiredHome 37:f19b7e7449dc 2605 //pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
WiredHome 37:f19b7e7449dc 2606 display.pixel(x,y, display.DOSColor(c));
WiredHome 37:f19b7e7449dc 2607 }
WiredHome 37:f19b7e7449dc 2608 }
WiredHome 37:f19b7e7449dc 2609
WiredHome 44:207594dece70 2610
WiredHome 23:a50ded45dbaf 2611 void LineTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2612 {
WiredHome 23:a50ded45dbaf 2613 int i, x, y, x2, y2;
WiredHome 23:a50ded45dbaf 2614
WiredHome 41:2956a0a221e5 2615 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2616 pc.printf("Line Test\r\n");
WiredHome 23:a50ded45dbaf 2617 display.background(Black);
WiredHome 23:a50ded45dbaf 2618 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2619 display.cls();
WiredHome 100:0b084475d5a9 2620 display.puts("Line Test");
WiredHome 23:a50ded45dbaf 2621 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2622 // Lines
WiredHome 23:a50ded45dbaf 2623 x = rand() % 480;
WiredHome 23:a50ded45dbaf 2624 y = rand() % 272;
WiredHome 23:a50ded45dbaf 2625 x2 = rand() % 480;
WiredHome 23:a50ded45dbaf 2626 y2 = rand() % 272;
WiredHome 23:a50ded45dbaf 2627 display.line(x,y, x2,y2, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2628 }
WiredHome 62:ba5d33438fda 2629 display.foreground(BrightRed);
WiredHome 62:ba5d33438fda 2630 display.foreground(BrightGreen);
WiredHome 62:ba5d33438fda 2631 display.foreground(BrightBlue);
WiredHome 62:ba5d33438fda 2632 display.line(55,50, 79,74, BrightRed);
WiredHome 62:ba5d33438fda 2633 display.line(57,50, 81,74, BrightGreen);
WiredHome 62:ba5d33438fda 2634 display.line(59,50, 83,74, BrightBlue);
WiredHome 62:ba5d33438fda 2635 // horz
WiredHome 62:ba5d33438fda 2636 display.line(30,40, 32,40, BrightRed);
WiredHome 62:ba5d33438fda 2637 display.line(30,42, 32,42, BrightGreen);
WiredHome 62:ba5d33438fda 2638 display.line(30,44, 32,44, BrightBlue);
WiredHome 62:ba5d33438fda 2639 // vert
WiredHome 62:ba5d33438fda 2640 display.line(20,40, 20,42, BrightRed);
WiredHome 62:ba5d33438fda 2641 display.line(22,40, 22,42, BrightGreen);
WiredHome 62:ba5d33438fda 2642 display.line(24,40, 24,42, BrightBlue);
WiredHome 62:ba5d33438fda 2643 // compare point to line-point
WiredHome 62:ba5d33438fda 2644 display.pixel(20,50, BrightRed);
WiredHome 62:ba5d33438fda 2645 display.pixel(22,50, BrightGreen);
WiredHome 62:ba5d33438fda 2646 display.pixel(24,50, BrightBlue);
WiredHome 62:ba5d33438fda 2647 display.line(20,52, 20,52, BrightRed);
WiredHome 62:ba5d33438fda 2648 display.line(22,52, 22,52, BrightGreen);
WiredHome 62:ba5d33438fda 2649 display.line(24,52, 24,52, BrightBlue);
WiredHome 73:f22a18707b5e 2650
WiredHome 62:ba5d33438fda 2651 // point
WiredHome 62:ba5d33438fda 2652 display.line(50,50, 50,50, Red);
WiredHome 62:ba5d33438fda 2653 display.line(52,52, 52,52, Green);
WiredHome 62:ba5d33438fda 2654 display.line(54,54, 54,54, Blue);
WiredHome 62:ba5d33438fda 2655 display.line(60,60, 60,60, BrightRed);
WiredHome 62:ba5d33438fda 2656 display.line(62,62, 62,62, BrightGreen);
WiredHome 62:ba5d33438fda 2657 display.line(64,64, 64,64, BrightBlue);
WiredHome 62:ba5d33438fda 2658 display.line(70,70, 70,70, DarkRed);
WiredHome 62:ba5d33438fda 2659 display.line(72,72, 72,72, DarkGreen);
WiredHome 62:ba5d33438fda 2660 display.line(74,74, 74,74, DarkBlue);
WiredHome 23:a50ded45dbaf 2661 }
WiredHome 23:a50ded45dbaf 2662
WiredHome 44:207594dece70 2663
WiredHome 23:a50ded45dbaf 2664 void RectangleTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2665 {
WiredHome 23:a50ded45dbaf 2666 int i, x1,y1, x2,y2;
WiredHome 23:a50ded45dbaf 2667
WiredHome 41:2956a0a221e5 2668 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2669 pc.printf("Rectangle Test\r\n");
WiredHome 23:a50ded45dbaf 2670 display.background(Black);
WiredHome 23:a50ded45dbaf 2671 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2672 display.cls();
WiredHome 100:0b084475d5a9 2673 display.puts("Rectangle Test");
WiredHome 23:a50ded45dbaf 2674 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2675 x1 = rand() % 240;
WiredHome 23:a50ded45dbaf 2676 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2677 x2 = rand() % 240;
WiredHome 23:a50ded45dbaf 2678 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2679 display.rect(x1,y1, x2,y2, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2680
WiredHome 23:a50ded45dbaf 2681 x1 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2682 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2683 x2 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2684 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2685 display.rect(x1,y1, x2,y2, FILL);
WiredHome 23:a50ded45dbaf 2686 }
WiredHome 23:a50ded45dbaf 2687 }
WiredHome 23:a50ded45dbaf 2688
WiredHome 44:207594dece70 2689
WiredHome 44:207594dece70 2690 void LayerTest(RA8875 & display, Serial & pc)
WiredHome 44:207594dece70 2691 {
WiredHome 44:207594dece70 2692 loc_t i, x1,y1, x2,y2, r1,r2;
WiredHome 44:207594dece70 2693
WiredHome 44:207594dece70 2694 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2695 pc.printf("Layer Test\r\n");
WiredHome 44:207594dece70 2696
WiredHome 50:2c4f474a2453 2697 display.SelectDrawingLayer(0);
WiredHome 44:207594dece70 2698 display.background(Black);
WiredHome 44:207594dece70 2699 display.foreground(Blue);
WiredHome 44:207594dece70 2700 display.cls();
WiredHome 100:0b084475d5a9 2701 display.puts("Layer 0");
WiredHome 44:207594dece70 2702 for (i=0; i<16; i++) {
WiredHome 44:207594dece70 2703 x1 = rand() % 240;
WiredHome 44:207594dece70 2704 y1 = 50 + rand() % 200;
WiredHome 44:207594dece70 2705 x2 = x1 + rand() % 100;
WiredHome 44:207594dece70 2706 y2 = y1 + rand() % 100;
WiredHome 44:207594dece70 2707 r1 = rand() % (x2 - x1)/2;
WiredHome 44:207594dece70 2708 r2 = rand() % (y2 - y1)/2;
WiredHome 44:207594dece70 2709 display.roundrect(x1,y1, x2,y2, r1,r2, display.DOSColor(i));
WiredHome 44:207594dece70 2710 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2711 wait_ms(20);
WiredHome 44:207594dece70 2712 }
WiredHome 44:207594dece70 2713 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2714 wait_ms(1000);
WiredHome 44:207594dece70 2715
WiredHome 50:2c4f474a2453 2716 display.SelectDrawingLayer(1);
WiredHome 44:207594dece70 2717 display.background(Black);
WiredHome 44:207594dece70 2718 display.foreground(Yellow);
WiredHome 44:207594dece70 2719 display.cls();
WiredHome 44:207594dece70 2720 display.puts(240,0, "Layer 1");
WiredHome 44:207594dece70 2721 for (i=0; i<16; i++) {
WiredHome 44:207594dece70 2722 x1 = 300 + rand() % 100;
WiredHome 44:207594dece70 2723 y1 = 70 + rand() % 200;
WiredHome 44:207594dece70 2724 r1 = rand() % min(y1 - 20, 100);
WiredHome 44:207594dece70 2725 display.circle(x1,y1,r1, display.DOSColor(i));
WiredHome 44:207594dece70 2726 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2727 wait_ms(20);
WiredHome 44:207594dece70 2728 }
WiredHome 56:7a85d226ad0d 2729 display.SetLayerMode(RA8875::ShowLayer1); // Show it after the build-up
WiredHome 44:207594dece70 2730 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2731 wait_ms(2000);
WiredHome 44:207594dece70 2732
WiredHome 50:2c4f474a2453 2733 display.SelectDrawingLayer(0);
WiredHome 56:7a85d226ad0d 2734 display.SetLayerMode(RA8875::ShowLayer0); // Show Layer 0 again
WiredHome 44:207594dece70 2735 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2736 wait_ms(1000);
WiredHome 53:86d24b9480b9 2737 display.SetLayerMode(RA8875::TransparentMode); // Transparent mode
WiredHome 44:207594dece70 2738 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2739 wait_ms(1000);
WiredHome 44:207594dece70 2740 for (i=0; i<=8; i++) {
WiredHome 44:207594dece70 2741 display.SetLayerTransparency(i, 8-i);
WiredHome 44:207594dece70 2742 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2743 wait_ms(200);
WiredHome 44:207594dece70 2744 }
WiredHome 73:f22a18707b5e 2745
WiredHome 44:207594dece70 2746 // Restore before we exit
WiredHome 44:207594dece70 2747 display.SetLayerTransparency(0, 0);
WiredHome 56:7a85d226ad0d 2748 display.SetLayerMode(RA8875::ShowLayer0); // Restore to layer 0
WiredHome 44:207594dece70 2749 }
WiredHome 44:207594dece70 2750
WiredHome 44:207594dece70 2751
WiredHome 23:a50ded45dbaf 2752 void RoundRectTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2753 {
WiredHome 37:f19b7e7449dc 2754 loc_t i, x1,y1, x2,y2, r1,r2;
WiredHome 23:a50ded45dbaf 2755
WiredHome 41:2956a0a221e5 2756 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2757 pc.printf("Round Rectangle Test\r\n");
WiredHome 23:a50ded45dbaf 2758 display.background(Black);
WiredHome 23:a50ded45dbaf 2759 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2760 display.cls();
WiredHome 100:0b084475d5a9 2761 display.puts("Rounded Rectangle Test");
WiredHome 73:f22a18707b5e 2762
WiredHome 23:a50ded45dbaf 2763 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2764 x1 = rand() % 240;
WiredHome 23:a50ded45dbaf 2765 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2766 x2 = x1 + rand() % 100;
WiredHome 23:a50ded45dbaf 2767 y2 = y1 + rand() % 100;
WiredHome 23:a50ded45dbaf 2768 r1 = rand() % (x2 - x1)/2;
WiredHome 23:a50ded45dbaf 2769 r2 = rand() % (y2 - y1)/2;
WiredHome 23:a50ded45dbaf 2770 display.roundrect(x1,y1, x2,y2, 5,8, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2771
WiredHome 23:a50ded45dbaf 2772 x1 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2773 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2774 x2 = x1 + rand() % 100;
WiredHome 23:a50ded45dbaf 2775 y2 = y1 + rand() % 100;
WiredHome 23:a50ded45dbaf 2776 r1 = rand() % (x2 - x1)/2;
WiredHome 23:a50ded45dbaf 2777 r2 = rand() % (y2 - y1)/2;
WiredHome 23:a50ded45dbaf 2778 display.roundrect(x1,y1, x2,y2, r1,r2, FILL);
WiredHome 23:a50ded45dbaf 2779 }
WiredHome 23:a50ded45dbaf 2780 }
WiredHome 23:a50ded45dbaf 2781
WiredHome 44:207594dece70 2782
WiredHome 23:a50ded45dbaf 2783 void TriangleTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2784 {
WiredHome 23:a50ded45dbaf 2785 int i, x1, y1, x2, y2, x3, y3;
WiredHome 23:a50ded45dbaf 2786
WiredHome 41:2956a0a221e5 2787 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2788 pc.printf("Triangle Test\r\n");
WiredHome 23:a50ded45dbaf 2789 display.background(Black);
WiredHome 23:a50ded45dbaf 2790 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2791 display.cls();
WiredHome 23:a50ded45dbaf 2792 display.puts(0,0, "Triangle Test");
WiredHome 23:a50ded45dbaf 2793
WiredHome 23:a50ded45dbaf 2794 x1 = 150;
WiredHome 23:a50ded45dbaf 2795 y1 = 2;
WiredHome 23:a50ded45dbaf 2796 x2 = 190;
WiredHome 23:a50ded45dbaf 2797 y2 = 7;
WiredHome 23:a50ded45dbaf 2798 x3 = 170;
WiredHome 23:a50ded45dbaf 2799 y3 = 16;
WiredHome 23:a50ded45dbaf 2800 display.triangle(x1,y1, x2,y2, x3,y3);
WiredHome 23:a50ded45dbaf 2801
WiredHome 23:a50ded45dbaf 2802 x1 = 200;
WiredHome 23:a50ded45dbaf 2803 y1 = 2;
WiredHome 23:a50ded45dbaf 2804 x2 = 240;
WiredHome 23:a50ded45dbaf 2805 y2 = 7;
WiredHome 23:a50ded45dbaf 2806 x3 = 220;
WiredHome 23:a50ded45dbaf 2807 y3 = 16;
WiredHome 23:a50ded45dbaf 2808 display.filltriangle(x1,y1, x2,y2, x3,y3, BrightRed);
WiredHome 23:a50ded45dbaf 2809
WiredHome 23:a50ded45dbaf 2810 x1 = 300;
WiredHome 23:a50ded45dbaf 2811 y1 = 2;
WiredHome 23:a50ded45dbaf 2812 x2 = 340;
WiredHome 23:a50ded45dbaf 2813 y2 = 7;
WiredHome 23:a50ded45dbaf 2814 x3 = 320;
WiredHome 23:a50ded45dbaf 2815 y3 = 16;
WiredHome 23:a50ded45dbaf 2816 display.triangle(x1,y1, x2,y2, x3,y3, NOFILL);
WiredHome 23:a50ded45dbaf 2817
WiredHome 23:a50ded45dbaf 2818 x1 = 400;
WiredHome 23:a50ded45dbaf 2819 y1 = 2;
WiredHome 23:a50ded45dbaf 2820 x2 = 440;
WiredHome 23:a50ded45dbaf 2821 y2 = 7;
WiredHome 23:a50ded45dbaf 2822 x3 = 420;
WiredHome 23:a50ded45dbaf 2823 y3 = 16;
WiredHome 23:a50ded45dbaf 2824 display.triangle(x1,y1, x2,y2, x3,y3, Blue);
WiredHome 23:a50ded45dbaf 2825
WiredHome 23:a50ded45dbaf 2826 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2827 x1 = rand() % 240;
WiredHome 23:a50ded45dbaf 2828 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2829 x2 = rand() % 240;
WiredHome 23:a50ded45dbaf 2830 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2831 x3 = rand() % 240;
WiredHome 23:a50ded45dbaf 2832 y3 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2833 display.triangle(x1,y1, x2,y2, x3,y3, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2834 x1 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2835 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2836 x2 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2837 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2838 x3 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2839 y3 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2840 display.triangle(x1,y1, x2,y2, x3,y3, FILL);
WiredHome 23:a50ded45dbaf 2841 }
WiredHome 23:a50ded45dbaf 2842 }
WiredHome 23:a50ded45dbaf 2843
WiredHome 44:207594dece70 2844
WiredHome 23:a50ded45dbaf 2845 void CircleTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2846 {
WiredHome 23:a50ded45dbaf 2847 int i, x, y, r1;
WiredHome 23:a50ded45dbaf 2848
WiredHome 41:2956a0a221e5 2849 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2850 pc.printf("Circle Test\r\n");
WiredHome 23:a50ded45dbaf 2851 display.background(Black);
WiredHome 23:a50ded45dbaf 2852 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2853 display.cls();
WiredHome 100:0b084475d5a9 2854 display.puts("Circle Test");
WiredHome 23:a50ded45dbaf 2855 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2856 x = 100 + rand() % 100;
WiredHome 23:a50ded45dbaf 2857 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2858 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2859 //pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
WiredHome 23:a50ded45dbaf 2860 display.circle(x,y,r1, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2861
WiredHome 23:a50ded45dbaf 2862 x = 300 + rand() % 100;
WiredHome 23:a50ded45dbaf 2863 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2864 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2865 //pc.printf(" (%d,%d) - %d FILL\r\n", x,y,r1);
WiredHome 23:a50ded45dbaf 2866 display.circle(x,y,r1, display.DOSColor(i), FILL);
WiredHome 23:a50ded45dbaf 2867 }
WiredHome 23:a50ded45dbaf 2868 }
WiredHome 23:a50ded45dbaf 2869
WiredHome 44:207594dece70 2870
WiredHome 23:a50ded45dbaf 2871 void EllipseTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2872 {
WiredHome 23:a50ded45dbaf 2873 int i,x,y,r1,r2;
WiredHome 23:a50ded45dbaf 2874
WiredHome 41:2956a0a221e5 2875 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2876 pc.printf("Ellipse Test\r\n");
WiredHome 23:a50ded45dbaf 2877 display.background(Black);
WiredHome 23:a50ded45dbaf 2878 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2879 display.cls();
WiredHome 100:0b084475d5a9 2880 display.puts("Ellipse Test");
WiredHome 23:a50ded45dbaf 2881 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2882 x = 100 + rand() % 100;
WiredHome 23:a50ded45dbaf 2883 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2884 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2885 r2 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2886 display.ellipse(x,y,r1,r2, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2887
WiredHome 23:a50ded45dbaf 2888 x = 300 + rand() % 100;
WiredHome 23:a50ded45dbaf 2889 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2890 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2891 r2 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2892 display.ellipse(x,y,r1,r2, FILL);
WiredHome 23:a50ded45dbaf 2893 }
WiredHome 23:a50ded45dbaf 2894 }
WiredHome 23:a50ded45dbaf 2895
WiredHome 44:207594dece70 2896
WiredHome 37:f19b7e7449dc 2897 void TestGraphicsBitmap(RA8875 & display, Serial & pc)
WiredHome 37:f19b7e7449dc 2898 {
WiredHome 37:f19b7e7449dc 2899 LocalFileSystem local("local");
WiredHome 41:2956a0a221e5 2900 if (!SuppressSlowStuff)
WiredHome 73:f22a18707b5e 2901 pc.printf("Bitmap File Load\r\n");
WiredHome 37:f19b7e7449dc 2902 display.background(Black);
WiredHome 37:f19b7e7449dc 2903 display.foreground(Blue);
WiredHome 37:f19b7e7449dc 2904 display.cls();
WiredHome 100:0b084475d5a9 2905 display.puts("Graphics Test, loading /local/TestPat.bmp");
WiredHome 37:f19b7e7449dc 2906 wait(3);
WiredHome 37:f19b7e7449dc 2907
WiredHome 37:f19b7e7449dc 2908 int r = display.RenderBitmapFile(0,0, "/local/TestPat.bmp");
WiredHome 59:fb40aad4efd4 2909 if (!SuppressSlowStuff)
WiredHome 59:fb40aad4efd4 2910 pc.printf(" returned %d\r\n", r);
WiredHome 37:f19b7e7449dc 2911 }
WiredHome 37:f19b7e7449dc 2912
WiredHome 44:207594dece70 2913
WiredHome 77:9206c13aa527 2914 void TouchPanelTest(RA8875 & display, Serial & pc)
WiredHome 77:9206c13aa527 2915 {
WiredHome 77:9206c13aa527 2916 Timer t;
WiredHome 98:ecebed9b80b2 2917 int x, y;
WiredHome 78:faf49c381591 2918 tpMatrix_t calmatrix;
WiredHome 78:faf49c381591 2919
WiredHome 77:9206c13aa527 2920 display.background(Black);
WiredHome 77:9206c13aa527 2921 display.foreground(Blue);
WiredHome 77:9206c13aa527 2922 display.cls();
WiredHome 100:0b084475d5a9 2923 display.puts("Touch Panel Test\r\n");
WiredHome 78:faf49c381591 2924 pc.printf("Touch Panel Test\r\n");
WiredHome 77:9206c13aa527 2925 display.TouchPanelInit();
WiredHome 78:faf49c381591 2926 pc.printf(" TP: c - calibrate, r - restore, t - test\r\n");
WiredHome 78:faf49c381591 2927 int c = pc.getc();
WiredHome 78:faf49c381591 2928 if (c == 'c') {
WiredHome 78:faf49c381591 2929 point_t pTest[3] =
WiredHome 78:faf49c381591 2930 { { 50, 50 }, {450, 150}, {225,250} };
WiredHome 78:faf49c381591 2931 point_t pSample[3];
WiredHome 78:faf49c381591 2932 for (int i=0; i<3; i++) {
WiredHome 78:faf49c381591 2933 display.foreground(Blue);
WiredHome 78:faf49c381591 2934 display.printf(" (%3d,%3d) => ", pTest[i].x, pTest[i].y);
WiredHome 78:faf49c381591 2935 display.line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, White);
WiredHome 78:faf49c381591 2936 display.line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, White);
WiredHome 79:544eb4964795 2937 while (!display.TouchPanelA2DFiltered(&x, &y))
WiredHome 78:faf49c381591 2938 wait_ms(20);
WiredHome 78:faf49c381591 2939 pSample[i].x = x;
WiredHome 78:faf49c381591 2940 pSample[i].y = y;
WiredHome 78:faf49c381591 2941 display.line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, Black);
WiredHome 78:faf49c381591 2942 display.line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, Black);
WiredHome 78:faf49c381591 2943 display.foreground(Blue);
WiredHome 78:faf49c381591 2944 display.printf(" (%4d,%4d)\r\n", x,y);
WiredHome 79:544eb4964795 2945 while (display.TouchPanelA2DFiltered(&x, &y))
WiredHome 78:faf49c381591 2946 wait_ms(20);
WiredHome 78:faf49c381591 2947 wait(2);
WiredHome 78:faf49c381591 2948 }
WiredHome 81:01da2e34283d 2949 display.TouchPanelComputeCalibration(pTest, pSample, &calmatrix);
WiredHome 78:faf49c381591 2950 display.printf(" Writing calibration to tpcal.cfg\r\n");
WiredHome 78:faf49c381591 2951 FILE * fh = fopen("/local/tpcal.cfg", "wb");
WiredHome 78:faf49c381591 2952 if (fh) {
WiredHome 78:faf49c381591 2953 fwrite(&calmatrix, sizeof(calmatrix), 1, fh);
WiredHome 78:faf49c381591 2954 fclose(fh);
WiredHome 78:faf49c381591 2955 }
WiredHome 78:faf49c381591 2956 display.printf(" Calibration is complete.");
WiredHome 78:faf49c381591 2957 } else if (c == 'r') {
WiredHome 78:faf49c381591 2958 display.printf(" Reading calibration from tpcal.cfg\r\n");
WiredHome 78:faf49c381591 2959 FILE * fh = fopen("/local/tpcal.cfg", "rb");
WiredHome 78:faf49c381591 2960 if (fh) {
WiredHome 78:faf49c381591 2961 fread(&calmatrix, sizeof(calmatrix), 1, fh);
WiredHome 78:faf49c381591 2962 fclose(fh);
WiredHome 78:faf49c381591 2963 }
WiredHome 78:faf49c381591 2964 display.printf(" Calibration is complete.");
WiredHome 78:faf49c381591 2965 display.TouchPanelSetMatrix(&calmatrix);
WiredHome 77:9206c13aa527 2966 }
WiredHome 77:9206c13aa527 2967 t.start();
WiredHome 77:9206c13aa527 2968 do {
WiredHome 77:9206c13aa527 2969 point_t point = {0, 0};
WiredHome 79:544eb4964795 2970 if (display.TouchPanelReadable(&point)) {
WiredHome 77:9206c13aa527 2971 display.pixel(point.x, point.y, Red);
WiredHome 77:9206c13aa527 2972 }
WiredHome 77:9206c13aa527 2973 } while (t.read_ms() < 30000);
WiredHome 77:9206c13aa527 2974 pc.printf(">");
WiredHome 77:9206c13aa527 2975 }
WiredHome 77:9206c13aa527 2976
WiredHome 77:9206c13aa527 2977
WiredHome 41:2956a0a221e5 2978 void SpeedTest(RA8875 & display, Serial & pc)
WiredHome 41:2956a0a221e5 2979 {
WiredHome 41:2956a0a221e5 2980 Timer t;
WiredHome 41:2956a0a221e5 2981 SuppressSlowStuff = true;
WiredHome 41:2956a0a221e5 2982 pc.printf("\r\nSpeedTest disables delays, runs tests, reports overall time.\r\n");
WiredHome 41:2956a0a221e5 2983 t.start();
WiredHome 41:2956a0a221e5 2984 // do stuff fast
WiredHome 41:2956a0a221e5 2985 TextCursorTest(display, pc);
WiredHome 49:c5182231d1b9 2986 TextWrapTest(display, pc);
WiredHome 41:2956a0a221e5 2987 BacklightTest(display, pc, 0);
WiredHome 41:2956a0a221e5 2988 BacklightTest2(display, pc);
WiredHome 41:2956a0a221e5 2989 ExternalFontTest(display, pc);
WiredHome 41:2956a0a221e5 2990 DOSColorTest(display, pc);
WiredHome 41:2956a0a221e5 2991 WebColorTest(display, pc);
WiredHome 41:2956a0a221e5 2992 PixelTest(display, pc);
WiredHome 41:2956a0a221e5 2993 LineTest(display, pc);
WiredHome 41:2956a0a221e5 2994 RectangleTest(display, pc);
WiredHome 41:2956a0a221e5 2995 RoundRectTest(display, pc);
WiredHome 41:2956a0a221e5 2996 TriangleTest(display, pc);
WiredHome 41:2956a0a221e5 2997 CircleTest(display, pc);
WiredHome 41:2956a0a221e5 2998 EllipseTest(display, pc);
WiredHome 44:207594dece70 2999 LayerTest(display, pc);
WiredHome 41:2956a0a221e5 3000 //TestGraphicsBitmap(display, pc);
WiredHome 41:2956a0a221e5 3001 pc.printf("SpeedTest completed in %d msec\r\n", t.read_ms());
WiredHome 73:f22a18707b5e 3002 #ifdef PERF_METRICS
WiredHome 41:2956a0a221e5 3003 display.ReportPerformance(pc);
WiredHome 73:f22a18707b5e 3004 #endif
WiredHome 41:2956a0a221e5 3005 SuppressSlowStuff = false;
WiredHome 41:2956a0a221e5 3006 }
WiredHome 41:2956a0a221e5 3007
WiredHome 44:207594dece70 3008
WiredHome 41:2956a0a221e5 3009 void PrintScreen(RA8875 & display, Serial & pc)
WiredHome 41:2956a0a221e5 3010 {
WiredHome 41:2956a0a221e5 3011 if (!SuppressSlowStuff)
WiredHome 73:f22a18707b5e 3012 pc.printf("PrintScreen\r\n");
WiredHome 41:2956a0a221e5 3013 display.PrintScreen( 0,0, 480,272, "/local/Capture.bmp");
WiredHome 41:2956a0a221e5 3014 }
WiredHome 41:2956a0a221e5 3015
WiredHome 44:207594dece70 3016
WiredHome 23:a50ded45dbaf 3017 void RunTestSet(RA8875 & lcd, Serial & pc)
WiredHome 23:a50ded45dbaf 3018 {
WiredHome 23:a50ded45dbaf 3019 int q = 0;
WiredHome 23:a50ded45dbaf 3020 int automode = 0;
WiredHome 49:c5182231d1b9 3021 const unsigned char modelist[] = "BDWtGLlFROTPCEbw"; // auto-test in this order.
WiredHome 23:a50ded45dbaf 3022
WiredHome 23:a50ded45dbaf 3023 while(1) {
WiredHome 23:a50ded45dbaf 3024 pc.printf("\r\n"
WiredHome 41:2956a0a221e5 3025 "B - Backlight up b - backlight dim\r\n"
WiredHome 41:2956a0a221e5 3026 "D - DOS Colors W - Web Colors\r\n"
WiredHome 41:2956a0a221e5 3027 "t - text cursor G - Graphics Bitmap\r\n"
WiredHome 41:2956a0a221e5 3028 "L - Lines F - external Font\r\n"
WiredHome 41:2956a0a221e5 3029 "R - Rectangles O - rOund rectangles\r\n"
WiredHome 41:2956a0a221e5 3030 "T - Triangles P - Pixels \r\n"
WiredHome 41:2956a0a221e5 3031 "C - Circles E - Ellipses\r\n"
WiredHome 41:2956a0a221e5 3032 "A - Auto Test mode S - Speed Test\r\n"
WiredHome 77:9206c13aa527 3033 "K - Keypad Test s - touch screen test\r\n"
WiredHome 41:2956a0a221e5 3034 "p - print screen r - reset \r\n"
WiredHome 49:c5182231d1b9 3035 "l - layer test w - wrapping text \r\n"
WiredHome 73:f22a18707b5e 3036 #ifdef PERF_METRICS
WiredHome 41:2956a0a221e5 3037 "0 - clear performance 1 - report performance\r\n"
WiredHome 73:f22a18707b5e 3038 #endif
WiredHome 23:a50ded45dbaf 3039 "> ");
WiredHome 23:a50ded45dbaf 3040 if (automode == -1 || pc.readable()) {
WiredHome 23:a50ded45dbaf 3041 automode = -1;
WiredHome 37:f19b7e7449dc 3042 q = pc.getc();
WiredHome 37:f19b7e7449dc 3043 while (pc.readable())
WiredHome 37:f19b7e7449dc 3044 pc.getc();
WiredHome 23:a50ded45dbaf 3045 } else if (automode >= 0) {
WiredHome 23:a50ded45dbaf 3046 q = modelist[automode];
WiredHome 23:a50ded45dbaf 3047 }
WiredHome 23:a50ded45dbaf 3048 switch(q) {
WiredHome 73:f22a18707b5e 3049 #ifdef PERF_METRICS
WiredHome 41:2956a0a221e5 3050 case '0':
WiredHome 41:2956a0a221e5 3051 lcd.ClearPerformance();
WiredHome 41:2956a0a221e5 3052 break;
WiredHome 41:2956a0a221e5 3053 case '1':
WiredHome 41:2956a0a221e5 3054 lcd.ReportPerformance(pc);
WiredHome 41:2956a0a221e5 3055 break;
WiredHome 73:f22a18707b5e 3056 #endif
WiredHome 23:a50ded45dbaf 3057 case 'A':
WiredHome 23:a50ded45dbaf 3058 automode = 0;
WiredHome 23:a50ded45dbaf 3059 break;
WiredHome 23:a50ded45dbaf 3060 case 'B':
WiredHome 41:2956a0a221e5 3061 BacklightTest(lcd, pc, 2);
WiredHome 23:a50ded45dbaf 3062 break;
WiredHome 23:a50ded45dbaf 3063 case 'b':
WiredHome 23:a50ded45dbaf 3064 BacklightTest2(lcd, pc);
WiredHome 23:a50ded45dbaf 3065 break;
WiredHome 23:a50ded45dbaf 3066 case 'D':
WiredHome 23:a50ded45dbaf 3067 DOSColorTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3068 break;
WiredHome 75:ca78388cfd77 3069 case 'K':
WiredHome 75:ca78388cfd77 3070 KeyPadTest(lcd, pc);
WiredHome 75:ca78388cfd77 3071 break;
WiredHome 23:a50ded45dbaf 3072 case 'W':
WiredHome 23:a50ded45dbaf 3073 WebColorTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3074 break;
WiredHome 23:a50ded45dbaf 3075 case 't':
WiredHome 23:a50ded45dbaf 3076 TextCursorTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3077 break;
WiredHome 49:c5182231d1b9 3078 case 'w':
WiredHome 49:c5182231d1b9 3079 TextWrapTest(lcd, pc);
WiredHome 49:c5182231d1b9 3080 break;
WiredHome 23:a50ded45dbaf 3081 case 'F':
WiredHome 23:a50ded45dbaf 3082 ExternalFontTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3083 break;
WiredHome 23:a50ded45dbaf 3084 case 'L':
WiredHome 23:a50ded45dbaf 3085 LineTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3086 break;
WiredHome 44:207594dece70 3087 case 'l':
WiredHome 44:207594dece70 3088 LayerTest(lcd, pc);
WiredHome 44:207594dece70 3089 break;
WiredHome 23:a50ded45dbaf 3090 case 'R':
WiredHome 23:a50ded45dbaf 3091 RectangleTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3092 break;
WiredHome 23:a50ded45dbaf 3093 case 'O':
WiredHome 23:a50ded45dbaf 3094 RoundRectTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3095 break;
WiredHome 41:2956a0a221e5 3096 case 'p':
WiredHome 41:2956a0a221e5 3097 PrintScreen(lcd, pc);
WiredHome 41:2956a0a221e5 3098 break;
WiredHome 41:2956a0a221e5 3099 case 'S':
WiredHome 41:2956a0a221e5 3100 SpeedTest(lcd, pc);
WiredHome 41:2956a0a221e5 3101 break;
WiredHome 77:9206c13aa527 3102 case 's':
WiredHome 77:9206c13aa527 3103 TouchPanelTest(lcd, pc);
WiredHome 77:9206c13aa527 3104 break;
WiredHome 23:a50ded45dbaf 3105 case 'T':
WiredHome 23:a50ded45dbaf 3106 TriangleTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3107 break;
WiredHome 37:f19b7e7449dc 3108 case 'P':
WiredHome 37:f19b7e7449dc 3109 PixelTest(lcd, pc);
WiredHome 37:f19b7e7449dc 3110 break;
WiredHome 37:f19b7e7449dc 3111 case 'G':
WiredHome 37:f19b7e7449dc 3112 TestGraphicsBitmap(lcd, pc);
WiredHome 37:f19b7e7449dc 3113 break;
WiredHome 23:a50ded45dbaf 3114 case 'C':
WiredHome 23:a50ded45dbaf 3115 CircleTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3116 break;
WiredHome 23:a50ded45dbaf 3117 case 'E':
WiredHome 23:a50ded45dbaf 3118 EllipseTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3119 break;
WiredHome 23:a50ded45dbaf 3120 case 'r':
WiredHome 23:a50ded45dbaf 3121 pc.printf("Resetting ...\r\n");
WiredHome 23:a50ded45dbaf 3122 wait_ms(20);
WiredHome 23:a50ded45dbaf 3123 mbed_reset();
WiredHome 23:a50ded45dbaf 3124 break;
WiredHome 75:ca78388cfd77 3125 case ' ':
WiredHome 75:ca78388cfd77 3126 break;
WiredHome 23:a50ded45dbaf 3127 default:
WiredHome 23:a50ded45dbaf 3128 printf("huh?\n");
WiredHome 23:a50ded45dbaf 3129 break;
WiredHome 23:a50ded45dbaf 3130 }
WiredHome 23:a50ded45dbaf 3131 if (automode >= 0) {
WiredHome 23:a50ded45dbaf 3132 automode++;
WiredHome 23:a50ded45dbaf 3133 if (automode >= sizeof(modelist))
WiredHome 23:a50ded45dbaf 3134 automode = 0;
WiredHome 23:a50ded45dbaf 3135 wait_ms(2000);
WiredHome 23:a50ded45dbaf 3136 }
WiredHome 23:a50ded45dbaf 3137 wait_ms(200);
WiredHome 23:a50ded45dbaf 3138 }
WiredHome 23:a50ded45dbaf 3139 }
WiredHome 23:a50ded45dbaf 3140
WiredHome 79:544eb4964795 3141 #endif // TESTENABLE