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@162:a2d7f1988711, 2019-02-11 (annotated)

Committer:
WiredHome
Date:
Mon Feb 11 03:44:42 2019 +0000
Revision:
162:a2d7f1988711
Parent:
157:1565f38ca44b
Child:
163:17526689a3ed
PrintScreen - bug fixes in header info and symmetry of RGB16toRGBQuad and RGBQuadToRGB16

Who changed what in which revision?

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