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@161:0215d0eec1a4, 2019-01-13 (annotated)

Committer:
WiredHome
Date:
Sun Jan 13 19:02:36 2019 +0000
Revision:
161:0215d0eec1a4
Parent:
157:1565f38ca44b
Child:
162:a2d7f1988711
Child:
172:7abb03bf31be
Readjusted font parameters - ; <space> width is 1/4 the character height,; '0' - '9' by default as sized to the width of the widest digit.; command line can still override digit width.

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 96:40b74dd3695b 2064 RetCode_t RA8875::PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h)
WiredHome 96:40b74dd3695b 2065 {
WiredHome 96:40b74dd3695b 2066 BITMAPFILEHEADER BMP_Header;
WiredHome 96:40b74dd3695b 2067 BITMAPINFOHEADER BMP_Info;
WiredHome 96:40b74dd3695b 2068 uint8_t * lineBuffer = NULL;
WiredHome 96:40b74dd3695b 2069 color_t * pixelBuffer = NULL;
WiredHome 96:40b74dd3695b 2070 color_t * pixelBuffer2 = NULL;
WiredHome 96:40b74dd3695b 2071
WiredHome 98:ecebed9b80b2 2072 INFO("(%d,%d) - (%d,%d)", x,y,w,h);
WiredHome 105:4f116006ba1f 2073 if (x >= 0 && x < screenwidth
WiredHome 105:4f116006ba1f 2074 && y >= 0 && y < screenheight
WiredHome 105:4f116006ba1f 2075 && w > 0 && x + w <= screenwidth
WiredHome 105:4f116006ba1f 2076 && h > 0 && y + h <= screenheight) {
WiredHome 96:40b74dd3695b 2077
WiredHome 96:40b74dd3695b 2078 BMP_Header.bfType = BF_TYPE;
WiredHome 96:40b74dd3695b 2079 BMP_Header.bfSize = (w * h * sizeof(RGBQUAD)) + sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 96:40b74dd3695b 2080 BMP_Header.bfReserved1 = 0;
WiredHome 96:40b74dd3695b 2081 BMP_Header.bfReserved2 = 0;
WiredHome 96:40b74dd3695b 2082 BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 96:40b74dd3695b 2083
WiredHome 96:40b74dd3695b 2084 BMP_Info.biSize = sizeof(BMP_Info);
WiredHome 96:40b74dd3695b 2085 BMP_Info.biWidth = w;
WiredHome 96:40b74dd3695b 2086 BMP_Info.biHeight = h;
WiredHome 96:40b74dd3695b 2087 BMP_Info.biPlanes = 1;
WiredHome 96:40b74dd3695b 2088 BMP_Info.biBitCount = 24;
WiredHome 96:40b74dd3695b 2089 BMP_Info.biCompression = BI_RGB;
WiredHome 96:40b74dd3695b 2090 BMP_Info.biSizeImage = 0;
WiredHome 96:40b74dd3695b 2091 BMP_Info.biXPelsPerMeter = 0;
WiredHome 96:40b74dd3695b 2092 BMP_Info.biYPelsPerMeter = 0;
WiredHome 96:40b74dd3695b 2093 BMP_Info.biClrUsed = 0;
WiredHome 96:40b74dd3695b 2094 BMP_Info.biClrImportant = 0;
WiredHome 96:40b74dd3695b 2095
WiredHome 96:40b74dd3695b 2096 // Allocate the memory we need to proceed
WiredHome 96:40b74dd3695b 2097 int lineBufSize = ((24 * w + 7)/8);
WiredHome 145:5eb2492acdda 2098 lineBuffer = (uint8_t *)swMalloc(lineBufSize);
WiredHome 96:40b74dd3695b 2099 if (lineBuffer == NULL) {
WiredHome 96:40b74dd3695b 2100 ERR("Not enough RAM for PrintScreen lineBuffer");
WiredHome 96:40b74dd3695b 2101 return(not_enough_ram);
WiredHome 96:40b74dd3695b 2102 }
WiredHome 96:40b74dd3695b 2103
WiredHome 96:40b74dd3695b 2104 #define DOUBLEBUF /* one larger buffer instead of two */
WiredHome 96:40b74dd3695b 2105
WiredHome 96:40b74dd3695b 2106 #ifdef DOUBLEBUF
WiredHome 96:40b74dd3695b 2107 // In the "#else", pixelBuffer2 malloc returns a value,
WiredHome 96:40b74dd3695b 2108 // but is actually causing a failure later.
WiredHome 96:40b74dd3695b 2109 // This test helps determine if it is truly out of memory,
WiredHome 96:40b74dd3695b 2110 // or if malloc is broken.
WiredHome 145:5eb2492acdda 2111 pixelBuffer = (color_t *)swMalloc(2 * w * sizeof(color_t));
WiredHome 96:40b74dd3695b 2112 pixelBuffer2 = pixelBuffer + (w * sizeof(color_t));
WiredHome 96:40b74dd3695b 2113 #else
WiredHome 145:5eb2492acdda 2114 pixelBuffer = (color_t *)swMalloc(w * sizeof(color_t));
WiredHome 145:5eb2492acdda 2115 pixelBuffer2 = (color_t *)swMalloc(w * sizeof(color_t));
WiredHome 96:40b74dd3695b 2116 #endif
WiredHome 96:40b74dd3695b 2117 if (pixelBuffer == NULL || pixelBuffer2 == NULL) {
WiredHome 96:40b74dd3695b 2118 ERR("Not enough RAM for pixelBuffer");
WiredHome 96:40b74dd3695b 2119 #ifndef DOUBLEBUF
WiredHome 96:40b74dd3695b 2120 if (pixelBuffer2)
WiredHome 145:5eb2492acdda 2121 swFree(pixelBuffer2);
WiredHome 96:40b74dd3695b 2122 #endif
WiredHome 96:40b74dd3695b 2123 if (pixelBuffer)
WiredHome 145:5eb2492acdda 2124 swFree(pixelBuffer);
WiredHome 145:5eb2492acdda 2125 swFree(lineBuffer);
WiredHome 96:40b74dd3695b 2126 return(not_enough_ram);
WiredHome 96:40b74dd3695b 2127 }
WiredHome 96:40b74dd3695b 2128
WiredHome 96:40b74dd3695b 2129 // Get the file primed...
WiredHome 96:40b74dd3695b 2130 privateCallback(OPEN, (uint8_t *)&BMP_Header.bfSize, 4);
WiredHome 96:40b74dd3695b 2131
WiredHome 96:40b74dd3695b 2132 // Be optimistic - don't check for errors.
WiredHome 96:40b74dd3695b 2133 HexDump("BMP_Header", (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome 96:40b74dd3695b 2134 //fwrite(&BMP_Header, sizeof(char), sizeof(BMP_Header), Image);
WiredHome 96:40b74dd3695b 2135 privateCallback(WRITE, (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome 96:40b74dd3695b 2136
WiredHome 96:40b74dd3695b 2137 HexDump("BMP_Info", (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome 96:40b74dd3695b 2138 //fwrite(&BMP_Info, sizeof(char), sizeof(BMP_Info), Image);
WiredHome 96:40b74dd3695b 2139 privateCallback(WRITE, (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome 96:40b74dd3695b 2140
WiredHome 96:40b74dd3695b 2141 //color_t transparency = GetBackgroundTransparencyColor();
WiredHome 96:40b74dd3695b 2142 LayerMode_T ltpr0 = GetLayerMode();
WiredHome 96:40b74dd3695b 2143
WiredHome 96:40b74dd3695b 2144 uint16_t prevLayer = GetDrawingLayer();
WiredHome 96:40b74dd3695b 2145 // If only one of the layers is visible, select that layer
WiredHome 96:40b74dd3695b 2146 switch(ltpr0) {
WiredHome 96:40b74dd3695b 2147 case ShowLayer0:
WiredHome 96:40b74dd3695b 2148 SelectDrawingLayer(0);
WiredHome 96:40b74dd3695b 2149 break;
WiredHome 96:40b74dd3695b 2150 case ShowLayer1:
WiredHome 96:40b74dd3695b 2151 SelectDrawingLayer(1);
WiredHome 96:40b74dd3695b 2152 break;
WiredHome 96:40b74dd3695b 2153 default:
WiredHome 96:40b74dd3695b 2154 break;
WiredHome 96:40b74dd3695b 2155 }
WiredHome 96:40b74dd3695b 2156
WiredHome 96:40b74dd3695b 2157 // Read the display from the last line toward the top
WiredHome 96:40b74dd3695b 2158 // so we can write the file in one pass.
WiredHome 96:40b74dd3695b 2159 for (int j = h - 1; j >= 0; j--) {
WiredHome 149:c62c4b2d6a15 2160 if (idle_callback) {
WiredHome 149:c62c4b2d6a15 2161 (*idle_callback)(progress, (h - 1 - j) * 100 / (h - 1));
WiredHome 149:c62c4b2d6a15 2162 }
WiredHome 149:c62c4b2d6a15 2163
WiredHome 96:40b74dd3695b 2164 if (ltpr0 >= 2) // Need to combine the layers...
WiredHome 96:40b74dd3695b 2165 SelectDrawingLayer(0); // so read layer 0 first
WiredHome 96:40b74dd3695b 2166 // Read one line of pixels to a local buffer
WiredHome 96:40b74dd3695b 2167 if (getPixelStream(pixelBuffer, w, x,y+j) != noerror) {
WiredHome 96:40b74dd3695b 2168 ERR("getPixelStream error, and no recovery handler...");
WiredHome 96:40b74dd3695b 2169 }
WiredHome 96:40b74dd3695b 2170 if (ltpr0 >= 2) { // Need to combine the layers...
WiredHome 96:40b74dd3695b 2171 SelectDrawingLayer(1); // so read layer 1 next
WiredHome 96:40b74dd3695b 2172 if (getPixelStream(pixelBuffer2, w, x,y+j) != noerror) {
WiredHome 96:40b74dd3695b 2173 ERR("getPixelStream error, and no recovery handler...");
WiredHome 96:40b74dd3695b 2174 }
WiredHome 96:40b74dd3695b 2175 }
WiredHome 96:40b74dd3695b 2176 INFO("1st Color: %04X", pixelBuffer[0]);
WiredHome 96:40b74dd3695b 2177 HexDump("Raster", (uint8_t *)pixelBuffer, w);
WiredHome 96:40b74dd3695b 2178 // Convert the local buffer to RGBQUAD format
WiredHome 96:40b74dd3695b 2179 int lb = 0;
WiredHome 96:40b74dd3695b 2180 for (int i=0; i<w; i++) {
WiredHome 96:40b74dd3695b 2181 RGBQUAD q0 = RGB16ToRGBQuad(pixelBuffer[x+i]); // Scale to 24-bits
WiredHome 96:40b74dd3695b 2182 RGBQUAD q1 = RGB16ToRGBQuad(pixelBuffer2[x+i]); // Scale to 24-bits
WiredHome 96:40b74dd3695b 2183 switch (ltpr0) {
WiredHome 96:40b74dd3695b 2184 case 0:
WiredHome 96:40b74dd3695b 2185 case 1:
WiredHome 96:40b74dd3695b 2186 case 2: // lighten-overlay (@TODO Not supported yet)
WiredHome 96:40b74dd3695b 2187 case 6: // Floating Windows (@TODO not sure how to support)
WiredHome 96:40b74dd3695b 2188 default: // Reserved...
WiredHome 96:40b74dd3695b 2189 lineBuffer[lb++] = q0.rgbBlue;
WiredHome 96:40b74dd3695b 2190 lineBuffer[lb++] = q0.rgbGreen;
WiredHome 96:40b74dd3695b 2191 lineBuffer[lb++] = q0.rgbRed;
WiredHome 96:40b74dd3695b 2192 break;
WiredHome 96:40b74dd3695b 2193 case 3: // transparent mode (@TODO Read the background color register for transparent)
WiredHome 96:40b74dd3695b 2194 case 4: // boolean or
WiredHome 96:40b74dd3695b 2195 lineBuffer[lb++] = q0.rgbBlue | q1.rgbBlue;
WiredHome 96:40b74dd3695b 2196 lineBuffer[lb++] = q0.rgbGreen | q1.rgbGreen;
WiredHome 96:40b74dd3695b 2197 lineBuffer[lb++] = q0.rgbRed | q1.rgbRed;
WiredHome 96:40b74dd3695b 2198 break;
WiredHome 96:40b74dd3695b 2199 case 5: // boolean AND
WiredHome 96:40b74dd3695b 2200 lineBuffer[lb++] = q0.rgbBlue & q1.rgbBlue;
WiredHome 96:40b74dd3695b 2201 lineBuffer[lb++] = q0.rgbGreen & q1.rgbGreen;
WiredHome 96:40b74dd3695b 2202 lineBuffer[lb++] = q0.rgbRed & q1.rgbRed;
WiredHome 96:40b74dd3695b 2203 break;
WiredHome 96:40b74dd3695b 2204 }
WiredHome 96:40b74dd3695b 2205 }
WiredHome 96:40b74dd3695b 2206 if (j == h - 1) {
WiredHome 96:40b74dd3695b 2207 HexDump("Line", lineBuffer, lineBufSize);
WiredHome 96:40b74dd3695b 2208 }
WiredHome 96:40b74dd3695b 2209 // Write to disk
WiredHome 96:40b74dd3695b 2210 //fwrite(lineBuffer, sizeof(char), lb, Image);
WiredHome 96:40b74dd3695b 2211 privateCallback(WRITE, (uint8_t *)lineBuffer, lb);
WiredHome 96:40b74dd3695b 2212 }
WiredHome 96:40b74dd3695b 2213 SelectDrawingLayer(prevLayer);
WiredHome 96:40b74dd3695b 2214 //fclose(Image);
WiredHome 96:40b74dd3695b 2215 privateCallback(CLOSE, NULL, 0);
WiredHome 96:40b74dd3695b 2216
WiredHome 96:40b74dd3695b 2217 #ifndef DOUBLEBUF
WiredHome 96:40b74dd3695b 2218 if (pixelBuffer2)
WiredHome 145:5eb2492acdda 2219 swFree(pixelBuffer2);
WiredHome 96:40b74dd3695b 2220 #endif
WiredHome 96:40b74dd3695b 2221 if (pixelBuffer)
WiredHome 145:5eb2492acdda 2222 swFree(pixelBuffer);
WiredHome 145:5eb2492acdda 2223 swFree(lineBuffer);
WiredHome 96:40b74dd3695b 2224 INFO("Image closed");
WiredHome 96:40b74dd3695b 2225 return noerror;
WiredHome 96:40b74dd3695b 2226 } else {
WiredHome 96:40b74dd3695b 2227 return bad_parameter;
WiredHome 96:40b74dd3695b 2228 }
WiredHome 96:40b74dd3695b 2229 }
WiredHome 79:544eb4964795 2230
WiredHome 72:ecffe56af969 2231 RetCode_t RA8875::PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP)
WiredHome 72:ecffe56af969 2232 {
WiredHome 72:ecffe56af969 2233 BITMAPFILEHEADER BMP_Header;
WiredHome 72:ecffe56af969 2234 BITMAPINFOHEADER BMP_Info;
WiredHome 86:e86b355940f4 2235 uint8_t * lineBuffer = NULL;
WiredHome 86:e86b355940f4 2236 color_t * pixelBuffer = NULL;
WiredHome 86:e86b355940f4 2237 color_t * pixelBuffer2 = NULL;
WiredHome 86:e86b355940f4 2238
WiredHome 72:ecffe56af969 2239 INFO("(%d,%d) - (%d,%d) %s", x,y,w,h,Name_BMP);
WiredHome 105:4f116006ba1f 2240 if (x >= 0 && x < screenwidth
WiredHome 105:4f116006ba1f 2241 && y >= 0 && y < screenheight
WiredHome 105:4f116006ba1f 2242 && w > 0 && x + w <= screenwidth
WiredHome 105:4f116006ba1f 2243 && h > 0 && y + h <= screenheight) {
WiredHome 72:ecffe56af969 2244
WiredHome 72:ecffe56af969 2245 BMP_Header.bfType = BF_TYPE;
WiredHome 72:ecffe56af969 2246 BMP_Header.bfSize = (w * h * sizeof(RGBQUAD)) + sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 72:ecffe56af969 2247 BMP_Header.bfReserved1 = 0;
WiredHome 72:ecffe56af969 2248 BMP_Header.bfReserved2 = 0;
WiredHome 72:ecffe56af969 2249 BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 73:f22a18707b5e 2250
WiredHome 72:ecffe56af969 2251 BMP_Info.biSize = sizeof(BMP_Info);
WiredHome 72:ecffe56af969 2252 BMP_Info.biWidth = w;
WiredHome 72:ecffe56af969 2253 BMP_Info.biHeight = h;
WiredHome 72:ecffe56af969 2254 BMP_Info.biPlanes = 1;
WiredHome 72:ecffe56af969 2255 BMP_Info.biBitCount = 24;
WiredHome 72:ecffe56af969 2256 BMP_Info.biCompression = BI_RGB;
WiredHome 72:ecffe56af969 2257 BMP_Info.biSizeImage = 0;
WiredHome 72:ecffe56af969 2258 BMP_Info.biXPelsPerMeter = 0;
WiredHome 72:ecffe56af969 2259 BMP_Info.biYPelsPerMeter = 0;
WiredHome 72:ecffe56af969 2260 BMP_Info.biClrUsed = 0;
WiredHome 72:ecffe56af969 2261 BMP_Info.biClrImportant = 0;
WiredHome 72:ecffe56af969 2262
WiredHome 86:e86b355940f4 2263 // Allocate the memory we need to proceed
WiredHome 86:e86b355940f4 2264 int lineBufSize = ((24 * w + 7)/8);
WiredHome 145:5eb2492acdda 2265 lineBuffer = (uint8_t *)swMalloc(lineBufSize);
WiredHome 86:e86b355940f4 2266 if (lineBuffer == NULL) {
WiredHome 86:e86b355940f4 2267 ERR("Not enough RAM for PrintScreen lineBuffer");
WiredHome 86:e86b355940f4 2268 return(not_enough_ram);
WiredHome 86:e86b355940f4 2269 }
WiredHome 86:e86b355940f4 2270
WiredHome 86:e86b355940f4 2271 #define DOUBLEBUF /* one larger buffer instead of two */
WiredHome 86:e86b355940f4 2272
WiredHome 86:e86b355940f4 2273 #ifdef DOUBLEBUF
WiredHome 86:e86b355940f4 2274 // In the "#else", pixelBuffer2 malloc returns a value,
WiredHome 86:e86b355940f4 2275 // but is actually causing a failure later.
WiredHome 86:e86b355940f4 2276 // This test helps determine if it is truly out of memory,
WiredHome 86:e86b355940f4 2277 // or if malloc is broken.
WiredHome 145:5eb2492acdda 2278 pixelBuffer = (color_t *)swMalloc(2 * w * sizeof(color_t));
WiredHome 86:e86b355940f4 2279 pixelBuffer2 = pixelBuffer + (w * sizeof(color_t));
WiredHome 86:e86b355940f4 2280 #else
WiredHome 145:5eb2492acdda 2281 pixelBuffer = (color_t *)swMalloc(w * sizeof(color_t));
WiredHome 145:5eb2492acdda 2282 pixelBuffer2 = (color_t *)swMalloc(w * sizeof(color_t));
WiredHome 86:e86b355940f4 2283 #endif
WiredHome 86:e86b355940f4 2284 if (pixelBuffer == NULL || pixelBuffer2 == NULL) {
WiredHome 86:e86b355940f4 2285 ERR("Not enough RAM for pixelBuffer");
WiredHome 86:e86b355940f4 2286 #ifndef DOUBLEBUF
WiredHome 86:e86b355940f4 2287 if (pixelBuffer2)
WiredHome 145:5eb2492acdda 2288 swFree(pixelBuffer2);
WiredHome 86:e86b355940f4 2289 #endif
WiredHome 86:e86b355940f4 2290 if (pixelBuffer)
WiredHome 145:5eb2492acdda 2291 swFree(pixelBuffer);
WiredHome 145:5eb2492acdda 2292 swFree(lineBuffer);
WiredHome 86:e86b355940f4 2293 return(not_enough_ram);
WiredHome 86:e86b355940f4 2294 }
WiredHome 86:e86b355940f4 2295
WiredHome 72:ecffe56af969 2296 FILE *Image = fopen(Name_BMP, "wb");
WiredHome 72:ecffe56af969 2297 if (!Image) {
WiredHome 86:e86b355940f4 2298 ERR("Can't open file for write");
WiredHome 86:e86b355940f4 2299 #ifndef DOUBLEBUF
WiredHome 86:e86b355940f4 2300 if (pixelBuffer2)
WiredHome 145:5eb2492acdda 2301 swFree(pixelBuffer2);
WiredHome 86:e86b355940f4 2302 #endif
WiredHome 86:e86b355940f4 2303 if (pixelBuffer)
WiredHome 145:5eb2492acdda 2304 swFree(pixelBuffer);
WiredHome 145:5eb2492acdda 2305 swFree(lineBuffer);
WiredHome 72:ecffe56af969 2306 return(file_not_found);
WiredHome 72:ecffe56af969 2307 }
WiredHome 72:ecffe56af969 2308
WiredHome 72:ecffe56af969 2309 // Be optimistic - don't check for errors.
WiredHome 93:6fbc516de05e 2310 HexDump("BMP_Header", (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome 95:ef538bd687c0 2311 fwrite(&BMP_Header, sizeof(char), sizeof(BMP_Header), Image);
WiredHome 73:f22a18707b5e 2312
WiredHome 93:6fbc516de05e 2313 HexDump("BMP_Info", (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome 95:ef538bd687c0 2314 fwrite(&BMP_Info, sizeof(char), sizeof(BMP_Info), Image);
WiredHome 73:f22a18707b5e 2315
WiredHome 95:ef538bd687c0 2316 //color_t transparency = GetBackgroundTransparencyColor();
WiredHome 95:ef538bd687c0 2317 LayerMode_T ltpr0 = GetLayerMode();
WiredHome 73:f22a18707b5e 2318
WiredHome 73:f22a18707b5e 2319 uint16_t prevLayer = GetDrawingLayer();
WiredHome 73:f22a18707b5e 2320 // If only one of the layers is visible, select that layer
WiredHome 73:f22a18707b5e 2321 switch(ltpr0) {
WiredHome 95:ef538bd687c0 2322 case ShowLayer0:
WiredHome 73:f22a18707b5e 2323 SelectDrawingLayer(0);
WiredHome 73:f22a18707b5e 2324 break;
WiredHome 95:ef538bd687c0 2325 case ShowLayer1:
WiredHome 73:f22a18707b5e 2326 SelectDrawingLayer(1);
WiredHome 73:f22a18707b5e 2327 break;
WiredHome 73:f22a18707b5e 2328 default:
WiredHome 73:f22a18707b5e 2329 break;
WiredHome 73:f22a18707b5e 2330 }
WiredHome 73:f22a18707b5e 2331
WiredHome 72:ecffe56af969 2332 // Read the display from the last line toward the top
WiredHome 72:ecffe56af969 2333 // so we can write the file in one pass.
WiredHome 72:ecffe56af969 2334 for (int j = h - 1; j >= 0; j--) {
WiredHome 149:c62c4b2d6a15 2335 if (idle_callback) {
WiredHome 149:c62c4b2d6a15 2336 (*idle_callback)(progress, (h - 1 - j) * 100 / (h - 1));
WiredHome 149:c62c4b2d6a15 2337 }
WiredHome 149:c62c4b2d6a15 2338
WiredHome 73:f22a18707b5e 2339 if (ltpr0 >= 2) // Need to combine the layers...
WiredHome 73:f22a18707b5e 2340 SelectDrawingLayer(0); // so read layer 0 first
WiredHome 72:ecffe56af969 2341 // Read one line of pixels to a local buffer
WiredHome 72:ecffe56af969 2342 if (getPixelStream(pixelBuffer, w, x,y+j) != noerror) {
WiredHome 72:ecffe56af969 2343 ERR("getPixelStream error, and no recovery handler...");
WiredHome 72:ecffe56af969 2344 }
WiredHome 73:f22a18707b5e 2345 if (ltpr0 >= 2) { // Need to combine the layers...
WiredHome 86:e86b355940f4 2346 SelectDrawingLayer(1); // so read layer 1 next
WiredHome 73:f22a18707b5e 2347 if (getPixelStream(pixelBuffer2, w, x,y+j) != noerror) {
WiredHome 73:f22a18707b5e 2348 ERR("getPixelStream error, and no recovery handler...");
WiredHome 73:f22a18707b5e 2349 }
WiredHome 73:f22a18707b5e 2350 }
WiredHome 93:6fbc516de05e 2351 INFO("1st Color: %04X", pixelBuffer[0]);
WiredHome 93:6fbc516de05e 2352 HexDump("Raster", (uint8_t *)pixelBuffer, w);
WiredHome 72:ecffe56af969 2353 // Convert the local buffer to RGBQUAD format
WiredHome 72:ecffe56af969 2354 int lb = 0;
WiredHome 72:ecffe56af969 2355 for (int i=0; i<w; i++) {
WiredHome 73:f22a18707b5e 2356 RGBQUAD q0 = RGB16ToRGBQuad(pixelBuffer[x+i]); // Scale to 24-bits
WiredHome 73:f22a18707b5e 2357 RGBQUAD q1 = RGB16ToRGBQuad(pixelBuffer2[x+i]); // Scale to 24-bits
WiredHome 73:f22a18707b5e 2358 switch (ltpr0) {
WiredHome 73:f22a18707b5e 2359 case 0:
WiredHome 73:f22a18707b5e 2360 case 1:
WiredHome 73:f22a18707b5e 2361 case 2: // lighten-overlay (@TODO Not supported yet)
WiredHome 73:f22a18707b5e 2362 case 6: // Floating Windows (@TODO not sure how to support)
WiredHome 73:f22a18707b5e 2363 default: // Reserved...
WiredHome 73:f22a18707b5e 2364 lineBuffer[lb++] = q0.rgbBlue;
WiredHome 73:f22a18707b5e 2365 lineBuffer[lb++] = q0.rgbGreen;
WiredHome 73:f22a18707b5e 2366 lineBuffer[lb++] = q0.rgbRed;
WiredHome 73:f22a18707b5e 2367 break;
WiredHome 73:f22a18707b5e 2368 case 3: // transparent mode (@TODO Read the background color register for transparent)
WiredHome 73:f22a18707b5e 2369 case 4: // boolean or
WiredHome 73:f22a18707b5e 2370 lineBuffer[lb++] = q0.rgbBlue | q1.rgbBlue;
WiredHome 73:f22a18707b5e 2371 lineBuffer[lb++] = q0.rgbGreen | q1.rgbGreen;
WiredHome 73:f22a18707b5e 2372 lineBuffer[lb++] = q0.rgbRed | q1.rgbRed;
WiredHome 73:f22a18707b5e 2373 break;
WiredHome 73:f22a18707b5e 2374 case 5: // boolean AND
WiredHome 73:f22a18707b5e 2375 lineBuffer[lb++] = q0.rgbBlue & q1.rgbBlue;
WiredHome 73:f22a18707b5e 2376 lineBuffer[lb++] = q0.rgbGreen & q1.rgbGreen;
WiredHome 73:f22a18707b5e 2377 lineBuffer[lb++] = q0.rgbRed & q1.rgbRed;
WiredHome 73:f22a18707b5e 2378 break;
WiredHome 73:f22a18707b5e 2379 }
WiredHome 72:ecffe56af969 2380 }
WiredHome 95:ef538bd687c0 2381 if (j == h - 1) {
WiredHome 73:f22a18707b5e 2382 HexDump("Line", lineBuffer, lineBufSize);
WiredHome 95:ef538bd687c0 2383 }
WiredHome 72:ecffe56af969 2384 // Write to disk
WiredHome 72:ecffe56af969 2385 fwrite(lineBuffer, sizeof(char), lb, Image);
WiredHome 72:ecffe56af969 2386 }
WiredHome 73:f22a18707b5e 2387 SelectDrawingLayer(prevLayer);
WiredHome 72:ecffe56af969 2388 fclose(Image);
WiredHome 86:e86b355940f4 2389 #ifndef DOUBLEBUF
WiredHome 86:e86b355940f4 2390 if (pixelBuffer2)
WiredHome 145:5eb2492acdda 2391 swFree(pixelBuffer2);
WiredHome 86:e86b355940f4 2392 #endif
WiredHome 86:e86b355940f4 2393 if (pixelBuffer)
WiredHome 145:5eb2492acdda 2394 swFree(pixelBuffer);
WiredHome 145:5eb2492acdda 2395 swFree(lineBuffer);
WiredHome 73:f22a18707b5e 2396 INFO("Image closed");
WiredHome 72:ecffe56af969 2397 return noerror;
WiredHome 72:ecffe56af969 2398 } else {
WiredHome 72:ecffe56af969 2399 return bad_parameter;
WiredHome 72:ecffe56af969 2400 }
WiredHome 72:ecffe56af969 2401 }
WiredHome 72:ecffe56af969 2402
WiredHome 72:ecffe56af969 2403
WiredHome 72:ecffe56af969 2404 // ##########################################################################
WiredHome 72:ecffe56af969 2405 // ##########################################################################
WiredHome 72:ecffe56af969 2406 // ##########################################################################
WiredHome 72:ecffe56af969 2407
WiredHome 23:a50ded45dbaf 2408 #ifdef TESTENABLE
WiredHome 23:a50ded45dbaf 2409
WiredHome 98:ecebed9b80b2 2410 #include "BPG_Arial08x08.h"
WiredHome 98:ecebed9b80b2 2411 #include "BPG_Arial20x20.h"
WiredHome 37:f19b7e7449dc 2412
WiredHome 23:a50ded45dbaf 2413 // ______________ ______________ ______________ _______________
WiredHome 23:a50ded45dbaf 2414 // /_____ _____/ / ___________/ / ___________/ /_____ ______/
WiredHome 23:a50ded45dbaf 2415 // / / / / / / / /
WiredHome 23:a50ded45dbaf 2416 // / / / /___ / /__________ / /
WiredHome 23:a50ded45dbaf 2417 // / / / ____/ /__________ / / /
WiredHome 23:a50ded45dbaf 2418 // / / / / / / / /
WiredHome 23:a50ded45dbaf 2419 // / / / /__________ ___________/ / / /
WiredHome 23:a50ded45dbaf 2420 // /__/ /_____________/ /_____________/ /__/
WiredHome 23:a50ded45dbaf 2421 //
WiredHome 23:a50ded45dbaf 2422 // Everything from here down is test code.
WiredHome 75:ca78388cfd77 2423 //
WiredHome 41:2956a0a221e5 2424 bool SuppressSlowStuff = false;
WiredHome 23:a50ded45dbaf 2425
WiredHome 49:c5182231d1b9 2426 void TextWrapTest(RA8875 & display, Serial & pc)
WiredHome 49:c5182231d1b9 2427 {
WiredHome 49:c5182231d1b9 2428 if (!SuppressSlowStuff)
WiredHome 49:c5182231d1b9 2429 pc.printf("Text Wrap Test\r\n");
WiredHome 49:c5182231d1b9 2430 display.background(Black);
WiredHome 49:c5182231d1b9 2431 display.foreground(Blue);
WiredHome 49:c5182231d1b9 2432 display.cls();
WiredHome 49:c5182231d1b9 2433 display.Backlight_u8(255);
WiredHome 100:0b084475d5a9 2434 display.puts("Text Wrap Test.\r\n");
WiredHome 52:e6039a823420 2435 for (int i=1; i<60; i++) {
WiredHome 52:e6039a823420 2436 display.printf("L%2d\n", i % 17);
WiredHome 49:c5182231d1b9 2437 if (!SuppressSlowStuff)
WiredHome 52:e6039a823420 2438 wait_ms(100);
WiredHome 49:c5182231d1b9 2439 }
WiredHome 49:c5182231d1b9 2440 if (!SuppressSlowStuff)
WiredHome 49:c5182231d1b9 2441 wait_ms(3000);
WiredHome 49:c5182231d1b9 2442 }
WiredHome 49:c5182231d1b9 2443
WiredHome 75:ca78388cfd77 2444
WiredHome 75:ca78388cfd77 2445 void ShowKey(RA8875 & display, int key)
WiredHome 75:ca78388cfd77 2446 {
WiredHome 75:ca78388cfd77 2447 loc_t col, row;
WiredHome 75:ca78388cfd77 2448 dim_t r1 = 25;
WiredHome 75:ca78388cfd77 2449 color_t color = (key & 0x80) ? Red : Green;
WiredHome 75:ca78388cfd77 2450
WiredHome 75:ca78388cfd77 2451 key &= 0x7F; // remove the long-press flag
WiredHome 75:ca78388cfd77 2452 row = (key - 1) / 5;
WiredHome 75:ca78388cfd77 2453 col = (key - 1) % 5;
WiredHome 75:ca78388cfd77 2454 if (col > 5) col = 5;
WiredHome 75:ca78388cfd77 2455 if (row > 4) row = 4;
WiredHome 75:ca78388cfd77 2456 display.circle(450 - + (2 * r1) * col, 200 - (2 * r1) * row, r1-2, color, FILL);
WiredHome 75:ca78388cfd77 2457 }
WiredHome 75:ca78388cfd77 2458
WiredHome 75:ca78388cfd77 2459 void HideKey(RA8875 & display, int key)
WiredHome 75:ca78388cfd77 2460 {
WiredHome 75:ca78388cfd77 2461 loc_t col, row;
WiredHome 75:ca78388cfd77 2462 dim_t r1 = 25;
WiredHome 75:ca78388cfd77 2463
WiredHome 75:ca78388cfd77 2464 row = (key - 1) / 5;
WiredHome 75:ca78388cfd77 2465 col = (key - 1) % 5;
WiredHome 75:ca78388cfd77 2466 if (col > 5) col = 5;
WiredHome 75:ca78388cfd77 2467 if (row > 4) row = 4;
WiredHome 75:ca78388cfd77 2468 display.background(Black);
WiredHome 75:ca78388cfd77 2469 display.circle(450 - (2 * r1) * col, 200 - (2 * r1) * row, r1-2, Black, FILL);
WiredHome 75:ca78388cfd77 2470 display.circle(450 - (2 * r1) * col, 200 - (2 * r1) * row, r1-2, Blue);
WiredHome 75:ca78388cfd77 2471 }
WiredHome 75:ca78388cfd77 2472
WiredHome 75:ca78388cfd77 2473 void KeyPadTest(RA8875 & display, Serial & pc)
WiredHome 75:ca78388cfd77 2474 {
WiredHome 75:ca78388cfd77 2475 const uint8_t myMap[22] = {
WiredHome 77:9206c13aa527 2476 0,
WiredHome 75:ca78388cfd77 2477 'a', 'b', 'c', 'd', 'e',
WiredHome 75:ca78388cfd77 2478 'f', 'g', 'h', 'i', 'j',
WiredHome 75:ca78388cfd77 2479 'k', 'l', 'm', 'n', 'o',
WiredHome 75:ca78388cfd77 2480 'p', 'q', 'r', 's', 't',
WiredHome 75:ca78388cfd77 2481 'x'
WiredHome 75:ca78388cfd77 2482 };
WiredHome 77:9206c13aa527 2483
WiredHome 75:ca78388cfd77 2484 display.background(Black);
WiredHome 75:ca78388cfd77 2485 display.foreground(Blue);
WiredHome 75:ca78388cfd77 2486 display.cls();
WiredHome 75:ca78388cfd77 2487 display.Backlight_u8(255);
WiredHome 100:0b084475d5a9 2488 display.puts("KeyPad Test. Touch the keypad...");
WiredHome 75:ca78388cfd77 2489 pc.printf("\r\n"
WiredHome 75:ca78388cfd77 2490 "Raw KeyPad Test. Keypad returns the key-number.\r\n"
WiredHome 75:ca78388cfd77 2491 "Press [most] any PC keyboard key to advance to next test.\r\n");
WiredHome 75:ca78388cfd77 2492 RetCode_t ret = display.KeypadInit(true, true, 3, 7, 3);
WiredHome 75:ca78388cfd77 2493 if (ret != noerror)
WiredHome 75:ca78388cfd77 2494 pc.printf("returncode from KeypadInit is %d\r\n", ret);
WiredHome 75:ca78388cfd77 2495 int lastKey = 0;
WiredHome 75:ca78388cfd77 2496 while (!pc.readable()) {
WiredHome 75:ca78388cfd77 2497 if (display.readable()) {
WiredHome 75:ca78388cfd77 2498 int key = display.getc();
WiredHome 75:ca78388cfd77 2499 if (key) {
WiredHome 75:ca78388cfd77 2500 if (((key & 0x7F) != lastKey) && (lastKey != 0))
WiredHome 75:ca78388cfd77 2501 HideKey(display, lastKey);
WiredHome 75:ca78388cfd77 2502 ShowKey(display, key);
WiredHome 75:ca78388cfd77 2503 lastKey = key & 0x7F;
WiredHome 75:ca78388cfd77 2504 } else {
WiredHome 75:ca78388cfd77 2505 // erase the last one
WiredHome 75:ca78388cfd77 2506 if (lastKey)
WiredHome 75:ca78388cfd77 2507 HideKey(display, lastKey);
WiredHome 75:ca78388cfd77 2508 }
WiredHome 75:ca78388cfd77 2509 }
WiredHome 75:ca78388cfd77 2510 }
WiredHome 75:ca78388cfd77 2511 (void)pc.getc();
WiredHome 75:ca78388cfd77 2512 pc.printf("\r\n"
WiredHome 75:ca78388cfd77 2513 "Map KeyPad Test. Keypad returns the remapped key 'a' - 't'.\r\n"
WiredHome 75:ca78388cfd77 2514 "Press [most] any PC keyboard key to advance to exit test.\r\n");
WiredHome 75:ca78388cfd77 2515 display.SetKeyMap(myMap);
WiredHome 75:ca78388cfd77 2516 while (!pc.readable()) {
WiredHome 75:ca78388cfd77 2517 if (display.readable()) {
WiredHome 75:ca78388cfd77 2518 int key = display.getc();
WiredHome 75:ca78388cfd77 2519 bool longPress = key & 0x80;
WiredHome 75:ca78388cfd77 2520 display.SetTextCursor(0, 120);
WiredHome 75:ca78388cfd77 2521 display.printf("Long Press: %d\r\n", longPress);
WiredHome 75:ca78388cfd77 2522 display.printf(" Remapped: %c %02X\r\n", (key) ? key & 0x7F : ' ', key);
WiredHome 75:ca78388cfd77 2523 }
WiredHome 75:ca78388cfd77 2524 }
WiredHome 75:ca78388cfd77 2525 (void)pc.getc();
WiredHome 75:ca78388cfd77 2526 display.SetKeyMap();
WiredHome 75:ca78388cfd77 2527 pc.printf("\r\n");
WiredHome 75:ca78388cfd77 2528 }
WiredHome 75:ca78388cfd77 2529
WiredHome 23:a50ded45dbaf 2530 void TextCursorTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2531 {
WiredHome 75:ca78388cfd77 2532 const char * iCursor = "The I-Beam cursor should be visible for this text.\r\n";
WiredHome 75:ca78388cfd77 2533 const char * uCursor = "The Underscore cursor should be visible for this text.\r\n";
WiredHome 75:ca78388cfd77 2534 const char * bCursor = "The Block cursor should be visible for this text.\r\n";
WiredHome 37:f19b7e7449dc 2535 const char * bbCursor = "The Blinking Block cursor should be visible for this text.\r\n";
WiredHome 23:a50ded45dbaf 2536 const char * p;
WiredHome 100:0b084475d5a9 2537 int delay = 60;
WiredHome 73:f22a18707b5e 2538
WiredHome 41:2956a0a221e5 2539 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2540 pc.printf("Text Cursor Test\r\n");
WiredHome 73:f22a18707b5e 2541 else
WiredHome 41:2956a0a221e5 2542 delay = 0;
WiredHome 23:a50ded45dbaf 2543 display.background(Black);
WiredHome 23:a50ded45dbaf 2544 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2545 display.cls();
WiredHome 25:9556a3a9b7cc 2546 display.Backlight_u8(255);
WiredHome 100:0b084475d5a9 2547 display.puts("Text Cursor Test.");
WiredHome 73:f22a18707b5e 2548
WiredHome 23:a50ded45dbaf 2549 // visible, non-blinking
WiredHome 24:8ca861acf12d 2550 display.SetTextCursor(0,20);
WiredHome 53:86d24b9480b9 2551 display.SetTextCursorControl(RA8875::IBEAM, false);
WiredHome 24:8ca861acf12d 2552 p = iCursor;
WiredHome 23:a50ded45dbaf 2553 while (*p) {
WiredHome 24:8ca861acf12d 2554 display._putc(*p++);
WiredHome 41:2956a0a221e5 2555 wait_ms(delay);
WiredHome 24:8ca861acf12d 2556 }
WiredHome 24:8ca861acf12d 2557
WiredHome 53:86d24b9480b9 2558 display.SetTextCursorControl(RA8875::UNDER, false);
WiredHome 24:8ca861acf12d 2559 p = uCursor;
WiredHome 24:8ca861acf12d 2560 while (*p) {
WiredHome 24:8ca861acf12d 2561 display._putc(*p++);
WiredHome 41:2956a0a221e5 2562 wait_ms(delay);
WiredHome 23:a50ded45dbaf 2563 }
WiredHome 73:f22a18707b5e 2564
WiredHome 53:86d24b9480b9 2565 display.SetTextCursorControl(RA8875::BLOCK, false);
WiredHome 24:8ca861acf12d 2566 p = bCursor;
WiredHome 24:8ca861acf12d 2567 while (*p) {
WiredHome 24:8ca861acf12d 2568 display._putc(*p++);
WiredHome 41:2956a0a221e5 2569 wait_ms(delay);
WiredHome 24:8ca861acf12d 2570 }
WiredHome 24:8ca861acf12d 2571
WiredHome 53:86d24b9480b9 2572 display.SetTextCursorControl(RA8875::BLOCK, true);
WiredHome 24:8ca861acf12d 2573 p = bbCursor;
WiredHome 24:8ca861acf12d 2574 while (*p) {
WiredHome 24:8ca861acf12d 2575 display._putc(*p++);
WiredHome 41:2956a0a221e5 2576 wait_ms(delay);
WiredHome 24:8ca861acf12d 2577 }
WiredHome 41:2956a0a221e5 2578 wait_ms(delay * 20);
WiredHome 53:86d24b9480b9 2579 display.SetTextCursorControl(RA8875::NOCURSOR, false);
WiredHome 23:a50ded45dbaf 2580 }
WiredHome 23:a50ded45dbaf 2581
WiredHome 44:207594dece70 2582
WiredHome 23:a50ded45dbaf 2583 void BacklightTest(RA8875 & display, Serial & pc, float ramptime)
WiredHome 23:a50ded45dbaf 2584 {
WiredHome 29:422616aa04bd 2585 char buf[60];
WiredHome 41:2956a0a221e5 2586 unsigned int w = (ramptime * 1000)/ 256;
WiredHome 41:2956a0a221e5 2587 int delay = 200;
WiredHome 41:2956a0a221e5 2588
WiredHome 41:2956a0a221e5 2589 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2590 pc.printf("Backlight Test - ramp over %f sec.\r\n", ramptime);
WiredHome 41:2956a0a221e5 2591 else {
WiredHome 41:2956a0a221e5 2592 delay = 0;
WiredHome 41:2956a0a221e5 2593 w = 0;
WiredHome 41:2956a0a221e5 2594 }
WiredHome 23:a50ded45dbaf 2595 display.Backlight_u8(0);
WiredHome 29:422616aa04bd 2596 display.background(White);
WiredHome 23:a50ded45dbaf 2597 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2598 display.cls();
WiredHome 100:0b084475d5a9 2599 display.puts("RA8875 Backlight Test - Ramp up.");
WiredHome 41:2956a0a221e5 2600 wait_ms(delay);
WiredHome 38:38d503b4fad6 2601 for (int i=0; i <= 255; i++) {
WiredHome 141:2ec78a50dc98 2602 snprintf(buf, sizeof(buf), "%3d, %4d", i, w);
WiredHome 37:f19b7e7449dc 2603 display.puts(100,100,buf);
WiredHome 23:a50ded45dbaf 2604 display.Backlight_u8(i);
WiredHome 29:422616aa04bd 2605 wait_ms(w);
WiredHome 23:a50ded45dbaf 2606 }
WiredHome 23:a50ded45dbaf 2607 }
WiredHome 23:a50ded45dbaf 2608
WiredHome 44:207594dece70 2609
WiredHome 23:a50ded45dbaf 2610 void BacklightTest2(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2611 {
WiredHome 41:2956a0a221e5 2612 int delay = 20;
WiredHome 41:2956a0a221e5 2613
WiredHome 41:2956a0a221e5 2614 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2615 pc.printf("Backlight Test 2\r\n");
WiredHome 41:2956a0a221e5 2616 else
WiredHome 41:2956a0a221e5 2617 delay = 0;
WiredHome 41:2956a0a221e5 2618
WiredHome 23:a50ded45dbaf 2619 // Dim it out at the end of the tests.
WiredHome 37:f19b7e7449dc 2620 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2621 display.puts(0,0, "Ramp Backlight down.");
WiredHome 23:a50ded45dbaf 2622 // Ramp it off
WiredHome 23:a50ded45dbaf 2623 for (int i=255; i != 0; i--) {
WiredHome 23:a50ded45dbaf 2624 display.Backlight_u8(i);
WiredHome 41:2956a0a221e5 2625 wait_ms(delay);
WiredHome 23:a50ded45dbaf 2626 }
WiredHome 23:a50ded45dbaf 2627 display.Backlight_u8(0);
WiredHome 23:a50ded45dbaf 2628 }
WiredHome 23:a50ded45dbaf 2629
WiredHome 44:207594dece70 2630
WiredHome 23:a50ded45dbaf 2631 void ExternalFontTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2632 {
WiredHome 41:2956a0a221e5 2633 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2634 pc.printf("External Font Test\r\n");
WiredHome 23:a50ded45dbaf 2635 display.background(Black);
WiredHome 23:a50ded45dbaf 2636 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2637 display.cls();
WiredHome 100:0b084475d5a9 2638 display.puts("External Font Test.");
WiredHome 23:a50ded45dbaf 2639 display.Backlight(1);
WiredHome 37:f19b7e7449dc 2640
WiredHome 98:ecebed9b80b2 2641 display.SelectUserFont(BPG_Arial08x08);
WiredHome 73:f22a18707b5e 2642 display.puts(0,30, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
WiredHome 37:f19b7e7449dc 2643
WiredHome 98:ecebed9b80b2 2644 display.SelectUserFont(BPG_Arial20x20);
WiredHome 37:f19b7e7449dc 2645 display.puts("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
WiredHome 98:ecebed9b80b2 2646
WiredHome 98:ecebed9b80b2 2647 display.SelectUserFont();
WiredHome 73:f22a18707b5e 2648
WiredHome 37:f19b7e7449dc 2649 display.puts("Normal font again.");
WiredHome 37:f19b7e7449dc 2650 //display.window(0,0, display.width(), display.height());
WiredHome 23:a50ded45dbaf 2651 }
WiredHome 23:a50ded45dbaf 2652
WiredHome 44:207594dece70 2653
WiredHome 23:a50ded45dbaf 2654 void DOSColorTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2655 {
WiredHome 41:2956a0a221e5 2656 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2657 pc.printf("DOS Color Test\r\n");
WiredHome 23:a50ded45dbaf 2658 display.background(Black);
WiredHome 23:a50ded45dbaf 2659 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2660 display.cls();
WiredHome 100:0b084475d5a9 2661 display.puts("DOS Colors - Fore");
WiredHome 23:a50ded45dbaf 2662 display.puts(280,0, "Back");
WiredHome 23:a50ded45dbaf 2663 display.background(Gray);
WiredHome 23:a50ded45dbaf 2664 for (int i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2665 display.foreground(display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2666 display.puts(160, i*16, display.DOSColorNames(i));
WiredHome 23:a50ded45dbaf 2667 display.background(Black);
WiredHome 23:a50ded45dbaf 2668 }
WiredHome 23:a50ded45dbaf 2669 display.foreground(White);
WiredHome 23:a50ded45dbaf 2670 for (int i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2671 display.background(display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2672 display.puts(360, i*16, display.DOSColorNames(i));
WiredHome 23:a50ded45dbaf 2673 display.foreground(White);
WiredHome 23:a50ded45dbaf 2674 }
WiredHome 23:a50ded45dbaf 2675 }
WiredHome 23:a50ded45dbaf 2676
WiredHome 44:207594dece70 2677
WiredHome 23:a50ded45dbaf 2678 void WebColorTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2679 {
WiredHome 41:2956a0a221e5 2680 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2681 pc.printf("Web Color Test\r\n");
WiredHome 23:a50ded45dbaf 2682 display.background(Black);
WiredHome 23:a50ded45dbaf 2683 display.foreground(Blue);
WiredHome 32:0e4f2ae512e2 2684 display.window(0,0, display.width(), display.height());
WiredHome 23:a50ded45dbaf 2685 display.cls();
WiredHome 59:fb40aad4efd4 2686 display.SetTextFontSize(1,1);
WiredHome 59:fb40aad4efd4 2687 display.puts(200,0, "Web Color Test");
WiredHome 59:fb40aad4efd4 2688 display.SetTextCursor(0,0);
WiredHome 59:fb40aad4efd4 2689 display.puts(" ");
WiredHome 59:fb40aad4efd4 2690 for (int i=0; i<16; i++)
WiredHome 59:fb40aad4efd4 2691 display.printf("%X", i&0xF);
WiredHome 59:fb40aad4efd4 2692 display.puts("\r\n0 ");
WiredHome 23:a50ded45dbaf 2693 for (int i=0; i<sizeof(WebColors)/sizeof(WebColors[0]); i++) {
WiredHome 23:a50ded45dbaf 2694 display.background(WebColors[i]);
WiredHome 23:a50ded45dbaf 2695 display.puts(" ");
WiredHome 59:fb40aad4efd4 2696 if (i % 16 == 15 && i < 255) {
WiredHome 59:fb40aad4efd4 2697 display.printf("\r\n%X ", ((i+1)/16));
WiredHome 59:fb40aad4efd4 2698 }
WiredHome 23:a50ded45dbaf 2699 }
WiredHome 23:a50ded45dbaf 2700 display.SetTextFontSize(1,1);
WiredHome 23:a50ded45dbaf 2701 }
WiredHome 23:a50ded45dbaf 2702
WiredHome 44:207594dece70 2703
WiredHome 37:f19b7e7449dc 2704 void PixelTest(RA8875 & display, Serial & pc)
WiredHome 37:f19b7e7449dc 2705 {
WiredHome 37:f19b7e7449dc 2706 int i, c, x, y;
WiredHome 37:f19b7e7449dc 2707
WiredHome 41:2956a0a221e5 2708 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2709 pc.printf("Pixel Test\r\n");
WiredHome 37:f19b7e7449dc 2710 display.background(Black);
WiredHome 37:f19b7e7449dc 2711 display.foreground(Blue);
WiredHome 37:f19b7e7449dc 2712 display.cls();
WiredHome 100:0b084475d5a9 2713 display.puts("Pixel Test");
WiredHome 37:f19b7e7449dc 2714 for (i=0; i<1000; i++) {
WiredHome 37:f19b7e7449dc 2715 x = rand() % 480;
WiredHome 37:f19b7e7449dc 2716 y = 16 + rand() % (272-16);
WiredHome 37:f19b7e7449dc 2717 c = rand() % 16;
WiredHome 37:f19b7e7449dc 2718 //pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
WiredHome 37:f19b7e7449dc 2719 display.pixel(x,y, display.DOSColor(c));
WiredHome 37:f19b7e7449dc 2720 }
WiredHome 37:f19b7e7449dc 2721 }
WiredHome 37:f19b7e7449dc 2722
WiredHome 44:207594dece70 2723
WiredHome 23:a50ded45dbaf 2724 void LineTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2725 {
WiredHome 23:a50ded45dbaf 2726 int i, x, y, x2, y2;
WiredHome 23:a50ded45dbaf 2727
WiredHome 41:2956a0a221e5 2728 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2729 pc.printf("Line Test\r\n");
WiredHome 23:a50ded45dbaf 2730 display.background(Black);
WiredHome 23:a50ded45dbaf 2731 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2732 display.cls();
WiredHome 100:0b084475d5a9 2733 display.puts("Line Test");
WiredHome 23:a50ded45dbaf 2734 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2735 // Lines
WiredHome 23:a50ded45dbaf 2736 x = rand() % 480;
WiredHome 23:a50ded45dbaf 2737 y = rand() % 272;
WiredHome 23:a50ded45dbaf 2738 x2 = rand() % 480;
WiredHome 23:a50ded45dbaf 2739 y2 = rand() % 272;
WiredHome 23:a50ded45dbaf 2740 display.line(x,y, x2,y2, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2741 }
WiredHome 62:ba5d33438fda 2742 display.foreground(BrightRed);
WiredHome 62:ba5d33438fda 2743 display.foreground(BrightGreen);
WiredHome 62:ba5d33438fda 2744 display.foreground(BrightBlue);
WiredHome 62:ba5d33438fda 2745 display.line(55,50, 79,74, BrightRed);
WiredHome 62:ba5d33438fda 2746 display.line(57,50, 81,74, BrightGreen);
WiredHome 62:ba5d33438fda 2747 display.line(59,50, 83,74, BrightBlue);
WiredHome 62:ba5d33438fda 2748 // horz
WiredHome 62:ba5d33438fda 2749 display.line(30,40, 32,40, BrightRed);
WiredHome 62:ba5d33438fda 2750 display.line(30,42, 32,42, BrightGreen);
WiredHome 62:ba5d33438fda 2751 display.line(30,44, 32,44, BrightBlue);
WiredHome 62:ba5d33438fda 2752 // vert
WiredHome 62:ba5d33438fda 2753 display.line(20,40, 20,42, BrightRed);
WiredHome 62:ba5d33438fda 2754 display.line(22,40, 22,42, BrightGreen);
WiredHome 62:ba5d33438fda 2755 display.line(24,40, 24,42, BrightBlue);
WiredHome 62:ba5d33438fda 2756 // compare point to line-point
WiredHome 62:ba5d33438fda 2757 display.pixel(20,50, BrightRed);
WiredHome 62:ba5d33438fda 2758 display.pixel(22,50, BrightGreen);
WiredHome 62:ba5d33438fda 2759 display.pixel(24,50, BrightBlue);
WiredHome 62:ba5d33438fda 2760 display.line(20,52, 20,52, BrightRed);
WiredHome 62:ba5d33438fda 2761 display.line(22,52, 22,52, BrightGreen);
WiredHome 62:ba5d33438fda 2762 display.line(24,52, 24,52, BrightBlue);
WiredHome 73:f22a18707b5e 2763
WiredHome 62:ba5d33438fda 2764 // point
WiredHome 62:ba5d33438fda 2765 display.line(50,50, 50,50, Red);
WiredHome 62:ba5d33438fda 2766 display.line(52,52, 52,52, Green);
WiredHome 62:ba5d33438fda 2767 display.line(54,54, 54,54, Blue);
WiredHome 62:ba5d33438fda 2768 display.line(60,60, 60,60, BrightRed);
WiredHome 62:ba5d33438fda 2769 display.line(62,62, 62,62, BrightGreen);
WiredHome 62:ba5d33438fda 2770 display.line(64,64, 64,64, BrightBlue);
WiredHome 62:ba5d33438fda 2771 display.line(70,70, 70,70, DarkRed);
WiredHome 62:ba5d33438fda 2772 display.line(72,72, 72,72, DarkGreen);
WiredHome 62:ba5d33438fda 2773 display.line(74,74, 74,74, DarkBlue);
WiredHome 23:a50ded45dbaf 2774 }
WiredHome 23:a50ded45dbaf 2775
WiredHome 44:207594dece70 2776
WiredHome 23:a50ded45dbaf 2777 void RectangleTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2778 {
WiredHome 23:a50ded45dbaf 2779 int i, x1,y1, x2,y2;
WiredHome 23:a50ded45dbaf 2780
WiredHome 41:2956a0a221e5 2781 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2782 pc.printf("Rectangle Test\r\n");
WiredHome 23:a50ded45dbaf 2783 display.background(Black);
WiredHome 23:a50ded45dbaf 2784 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2785 display.cls();
WiredHome 100:0b084475d5a9 2786 display.puts("Rectangle Test");
WiredHome 23:a50ded45dbaf 2787 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2788 x1 = rand() % 240;
WiredHome 23:a50ded45dbaf 2789 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2790 x2 = rand() % 240;
WiredHome 23:a50ded45dbaf 2791 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2792 display.rect(x1,y1, x2,y2, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2793
WiredHome 23:a50ded45dbaf 2794 x1 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2795 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2796 x2 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2797 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2798 display.rect(x1,y1, x2,y2, FILL);
WiredHome 23:a50ded45dbaf 2799 }
WiredHome 23:a50ded45dbaf 2800 }
WiredHome 23:a50ded45dbaf 2801
WiredHome 44:207594dece70 2802
WiredHome 44:207594dece70 2803 void LayerTest(RA8875 & display, Serial & pc)
WiredHome 44:207594dece70 2804 {
WiredHome 44:207594dece70 2805 loc_t i, x1,y1, x2,y2, r1,r2;
WiredHome 44:207594dece70 2806
WiredHome 44:207594dece70 2807 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2808 pc.printf("Layer Test\r\n");
WiredHome 44:207594dece70 2809
WiredHome 50:2c4f474a2453 2810 display.SelectDrawingLayer(0);
WiredHome 44:207594dece70 2811 display.background(Black);
WiredHome 44:207594dece70 2812 display.foreground(Blue);
WiredHome 44:207594dece70 2813 display.cls();
WiredHome 100:0b084475d5a9 2814 display.puts("Layer 0");
WiredHome 44:207594dece70 2815 for (i=0; i<16; i++) {
WiredHome 44:207594dece70 2816 x1 = rand() % 240;
WiredHome 44:207594dece70 2817 y1 = 50 + rand() % 200;
WiredHome 44:207594dece70 2818 x2 = x1 + rand() % 100;
WiredHome 44:207594dece70 2819 y2 = y1 + rand() % 100;
WiredHome 44:207594dece70 2820 r1 = rand() % (x2 - x1)/2;
WiredHome 44:207594dece70 2821 r2 = rand() % (y2 - y1)/2;
WiredHome 44:207594dece70 2822 display.roundrect(x1,y1, x2,y2, r1,r2, display.DOSColor(i));
WiredHome 44:207594dece70 2823 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2824 wait_ms(20);
WiredHome 44:207594dece70 2825 }
WiredHome 44:207594dece70 2826 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2827 wait_ms(1000);
WiredHome 44:207594dece70 2828
WiredHome 50:2c4f474a2453 2829 display.SelectDrawingLayer(1);
WiredHome 44:207594dece70 2830 display.background(Black);
WiredHome 44:207594dece70 2831 display.foreground(Yellow);
WiredHome 44:207594dece70 2832 display.cls();
WiredHome 44:207594dece70 2833 display.puts(240,0, "Layer 1");
WiredHome 44:207594dece70 2834 for (i=0; i<16; i++) {
WiredHome 44:207594dece70 2835 x1 = 300 + rand() % 100;
WiredHome 44:207594dece70 2836 y1 = 70 + rand() % 200;
WiredHome 44:207594dece70 2837 r1 = rand() % min(y1 - 20, 100);
WiredHome 44:207594dece70 2838 display.circle(x1,y1,r1, display.DOSColor(i));
WiredHome 44:207594dece70 2839 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2840 wait_ms(20);
WiredHome 44:207594dece70 2841 }
WiredHome 56:7a85d226ad0d 2842 display.SetLayerMode(RA8875::ShowLayer1); // Show it after the build-up
WiredHome 44:207594dece70 2843 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2844 wait_ms(2000);
WiredHome 44:207594dece70 2845
WiredHome 50:2c4f474a2453 2846 display.SelectDrawingLayer(0);
WiredHome 56:7a85d226ad0d 2847 display.SetLayerMode(RA8875::ShowLayer0); // Show Layer 0 again
WiredHome 44:207594dece70 2848 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2849 wait_ms(1000);
WiredHome 53:86d24b9480b9 2850 display.SetLayerMode(RA8875::TransparentMode); // Transparent mode
WiredHome 44:207594dece70 2851 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2852 wait_ms(1000);
WiredHome 44:207594dece70 2853 for (i=0; i<=8; i++) {
WiredHome 44:207594dece70 2854 display.SetLayerTransparency(i, 8-i);
WiredHome 44:207594dece70 2855 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 2856 wait_ms(200);
WiredHome 44:207594dece70 2857 }
WiredHome 73:f22a18707b5e 2858
WiredHome 44:207594dece70 2859 // Restore before we exit
WiredHome 44:207594dece70 2860 display.SetLayerTransparency(0, 0);
WiredHome 56:7a85d226ad0d 2861 display.SetLayerMode(RA8875::ShowLayer0); // Restore to layer 0
WiredHome 44:207594dece70 2862 }
WiredHome 44:207594dece70 2863
WiredHome 44:207594dece70 2864
WiredHome 23:a50ded45dbaf 2865 void RoundRectTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2866 {
WiredHome 37:f19b7e7449dc 2867 loc_t i, x1,y1, x2,y2, r1,r2;
WiredHome 23:a50ded45dbaf 2868
WiredHome 41:2956a0a221e5 2869 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2870 pc.printf("Round Rectangle Test\r\n");
WiredHome 23:a50ded45dbaf 2871 display.background(Black);
WiredHome 23:a50ded45dbaf 2872 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2873 display.cls();
WiredHome 100:0b084475d5a9 2874 display.puts("Rounded Rectangle Test");
WiredHome 73:f22a18707b5e 2875
WiredHome 23:a50ded45dbaf 2876 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2877 x1 = rand() % 240;
WiredHome 23:a50ded45dbaf 2878 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2879 x2 = x1 + rand() % 100;
WiredHome 23:a50ded45dbaf 2880 y2 = y1 + rand() % 100;
WiredHome 23:a50ded45dbaf 2881 r1 = rand() % (x2 - x1)/2;
WiredHome 23:a50ded45dbaf 2882 r2 = rand() % (y2 - y1)/2;
WiredHome 23:a50ded45dbaf 2883 display.roundrect(x1,y1, x2,y2, 5,8, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2884
WiredHome 23:a50ded45dbaf 2885 x1 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2886 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2887 x2 = x1 + rand() % 100;
WiredHome 23:a50ded45dbaf 2888 y2 = y1 + rand() % 100;
WiredHome 23:a50ded45dbaf 2889 r1 = rand() % (x2 - x1)/2;
WiredHome 23:a50ded45dbaf 2890 r2 = rand() % (y2 - y1)/2;
WiredHome 23:a50ded45dbaf 2891 display.roundrect(x1,y1, x2,y2, r1,r2, FILL);
WiredHome 23:a50ded45dbaf 2892 }
WiredHome 23:a50ded45dbaf 2893 }
WiredHome 23:a50ded45dbaf 2894
WiredHome 44:207594dece70 2895
WiredHome 23:a50ded45dbaf 2896 void TriangleTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2897 {
WiredHome 23:a50ded45dbaf 2898 int i, x1, y1, x2, y2, x3, y3;
WiredHome 23:a50ded45dbaf 2899
WiredHome 41:2956a0a221e5 2900 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2901 pc.printf("Triangle Test\r\n");
WiredHome 23:a50ded45dbaf 2902 display.background(Black);
WiredHome 23:a50ded45dbaf 2903 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2904 display.cls();
WiredHome 23:a50ded45dbaf 2905 display.puts(0,0, "Triangle Test");
WiredHome 23:a50ded45dbaf 2906
WiredHome 23:a50ded45dbaf 2907 x1 = 150;
WiredHome 23:a50ded45dbaf 2908 y1 = 2;
WiredHome 23:a50ded45dbaf 2909 x2 = 190;
WiredHome 23:a50ded45dbaf 2910 y2 = 7;
WiredHome 23:a50ded45dbaf 2911 x3 = 170;
WiredHome 23:a50ded45dbaf 2912 y3 = 16;
WiredHome 23:a50ded45dbaf 2913 display.triangle(x1,y1, x2,y2, x3,y3);
WiredHome 23:a50ded45dbaf 2914
WiredHome 23:a50ded45dbaf 2915 x1 = 200;
WiredHome 23:a50ded45dbaf 2916 y1 = 2;
WiredHome 23:a50ded45dbaf 2917 x2 = 240;
WiredHome 23:a50ded45dbaf 2918 y2 = 7;
WiredHome 23:a50ded45dbaf 2919 x3 = 220;
WiredHome 23:a50ded45dbaf 2920 y3 = 16;
WiredHome 23:a50ded45dbaf 2921 display.filltriangle(x1,y1, x2,y2, x3,y3, BrightRed);
WiredHome 23:a50ded45dbaf 2922
WiredHome 23:a50ded45dbaf 2923 x1 = 300;
WiredHome 23:a50ded45dbaf 2924 y1 = 2;
WiredHome 23:a50ded45dbaf 2925 x2 = 340;
WiredHome 23:a50ded45dbaf 2926 y2 = 7;
WiredHome 23:a50ded45dbaf 2927 x3 = 320;
WiredHome 23:a50ded45dbaf 2928 y3 = 16;
WiredHome 23:a50ded45dbaf 2929 display.triangle(x1,y1, x2,y2, x3,y3, NOFILL);
WiredHome 23:a50ded45dbaf 2930
WiredHome 23:a50ded45dbaf 2931 x1 = 400;
WiredHome 23:a50ded45dbaf 2932 y1 = 2;
WiredHome 23:a50ded45dbaf 2933 x2 = 440;
WiredHome 23:a50ded45dbaf 2934 y2 = 7;
WiredHome 23:a50ded45dbaf 2935 x3 = 420;
WiredHome 23:a50ded45dbaf 2936 y3 = 16;
WiredHome 23:a50ded45dbaf 2937 display.triangle(x1,y1, x2,y2, x3,y3, Blue);
WiredHome 23:a50ded45dbaf 2938
WiredHome 23:a50ded45dbaf 2939 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2940 x1 = rand() % 240;
WiredHome 23:a50ded45dbaf 2941 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2942 x2 = rand() % 240;
WiredHome 23:a50ded45dbaf 2943 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2944 x3 = rand() % 240;
WiredHome 23:a50ded45dbaf 2945 y3 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2946 display.triangle(x1,y1, x2,y2, x3,y3, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2947 x1 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2948 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2949 x2 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2950 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2951 x3 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 2952 y3 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 2953 display.triangle(x1,y1, x2,y2, x3,y3, FILL);
WiredHome 23:a50ded45dbaf 2954 }
WiredHome 23:a50ded45dbaf 2955 }
WiredHome 23:a50ded45dbaf 2956
WiredHome 44:207594dece70 2957
WiredHome 23:a50ded45dbaf 2958 void CircleTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2959 {
WiredHome 23:a50ded45dbaf 2960 int i, x, y, r1;
WiredHome 23:a50ded45dbaf 2961
WiredHome 41:2956a0a221e5 2962 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2963 pc.printf("Circle Test\r\n");
WiredHome 23:a50ded45dbaf 2964 display.background(Black);
WiredHome 23:a50ded45dbaf 2965 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2966 display.cls();
WiredHome 100:0b084475d5a9 2967 display.puts("Circle Test");
WiredHome 23:a50ded45dbaf 2968 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2969 x = 100 + rand() % 100;
WiredHome 23:a50ded45dbaf 2970 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2971 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2972 //pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
WiredHome 23:a50ded45dbaf 2973 display.circle(x,y,r1, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2974
WiredHome 23:a50ded45dbaf 2975 x = 300 + rand() % 100;
WiredHome 23:a50ded45dbaf 2976 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2977 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2978 //pc.printf(" (%d,%d) - %d FILL\r\n", x,y,r1);
WiredHome 23:a50ded45dbaf 2979 display.circle(x,y,r1, display.DOSColor(i), FILL);
WiredHome 23:a50ded45dbaf 2980 }
WiredHome 23:a50ded45dbaf 2981 }
WiredHome 23:a50ded45dbaf 2982
WiredHome 44:207594dece70 2983
WiredHome 23:a50ded45dbaf 2984 void EllipseTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2985 {
WiredHome 23:a50ded45dbaf 2986 int i,x,y,r1,r2;
WiredHome 23:a50ded45dbaf 2987
WiredHome 41:2956a0a221e5 2988 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2989 pc.printf("Ellipse Test\r\n");
WiredHome 23:a50ded45dbaf 2990 display.background(Black);
WiredHome 23:a50ded45dbaf 2991 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2992 display.cls();
WiredHome 100:0b084475d5a9 2993 display.puts("Ellipse Test");
WiredHome 23:a50ded45dbaf 2994 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2995 x = 100 + rand() % 100;
WiredHome 23:a50ded45dbaf 2996 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2997 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2998 r2 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2999 display.ellipse(x,y,r1,r2, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 3000
WiredHome 23:a50ded45dbaf 3001 x = 300 + rand() % 100;
WiredHome 23:a50ded45dbaf 3002 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 3003 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 3004 r2 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 3005 display.ellipse(x,y,r1,r2, FILL);
WiredHome 23:a50ded45dbaf 3006 }
WiredHome 23:a50ded45dbaf 3007 }
WiredHome 23:a50ded45dbaf 3008
WiredHome 44:207594dece70 3009
WiredHome 37:f19b7e7449dc 3010 void TestGraphicsBitmap(RA8875 & display, Serial & pc)
WiredHome 37:f19b7e7449dc 3011 {
WiredHome 37:f19b7e7449dc 3012 LocalFileSystem local("local");
WiredHome 41:2956a0a221e5 3013 if (!SuppressSlowStuff)
WiredHome 73:f22a18707b5e 3014 pc.printf("Bitmap File Load\r\n");
WiredHome 37:f19b7e7449dc 3015 display.background(Black);
WiredHome 37:f19b7e7449dc 3016 display.foreground(Blue);
WiredHome 37:f19b7e7449dc 3017 display.cls();
WiredHome 100:0b084475d5a9 3018 display.puts("Graphics Test, loading /local/TestPat.bmp");
WiredHome 37:f19b7e7449dc 3019 wait(3);
WiredHome 37:f19b7e7449dc 3020
WiredHome 37:f19b7e7449dc 3021 int r = display.RenderBitmapFile(0,0, "/local/TestPat.bmp");
WiredHome 59:fb40aad4efd4 3022 if (!SuppressSlowStuff)
WiredHome 59:fb40aad4efd4 3023 pc.printf(" returned %d\r\n", r);
WiredHome 37:f19b7e7449dc 3024 }
WiredHome 37:f19b7e7449dc 3025
WiredHome 44:207594dece70 3026
WiredHome 77:9206c13aa527 3027 void TouchPanelTest(RA8875 & display, Serial & pc)
WiredHome 77:9206c13aa527 3028 {
WiredHome 77:9206c13aa527 3029 Timer t;
WiredHome 98:ecebed9b80b2 3030 int x, y;
WiredHome 78:faf49c381591 3031 tpMatrix_t calmatrix;
WiredHome 78:faf49c381591 3032
WiredHome 77:9206c13aa527 3033 display.background(Black);
WiredHome 77:9206c13aa527 3034 display.foreground(Blue);
WiredHome 77:9206c13aa527 3035 display.cls();
WiredHome 100:0b084475d5a9 3036 display.puts("Touch Panel Test\r\n");
WiredHome 78:faf49c381591 3037 pc.printf("Touch Panel Test\r\n");
WiredHome 77:9206c13aa527 3038 display.TouchPanelInit();
WiredHome 78:faf49c381591 3039 pc.printf(" TP: c - calibrate, r - restore, t - test\r\n");
WiredHome 78:faf49c381591 3040 int c = pc.getc();
WiredHome 78:faf49c381591 3041 if (c == 'c') {
WiredHome 78:faf49c381591 3042 point_t pTest[3] =
WiredHome 78:faf49c381591 3043 { { 50, 50 }, {450, 150}, {225,250} };
WiredHome 78:faf49c381591 3044 point_t pSample[3];
WiredHome 78:faf49c381591 3045 for (int i=0; i<3; i++) {
WiredHome 78:faf49c381591 3046 display.foreground(Blue);
WiredHome 78:faf49c381591 3047 display.printf(" (%3d,%3d) => ", pTest[i].x, pTest[i].y);
WiredHome 78:faf49c381591 3048 display.line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, White);
WiredHome 78:faf49c381591 3049 display.line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, White);
WiredHome 79:544eb4964795 3050 while (!display.TouchPanelA2DFiltered(&x, &y))
WiredHome 78:faf49c381591 3051 wait_ms(20);
WiredHome 78:faf49c381591 3052 pSample[i].x = x;
WiredHome 78:faf49c381591 3053 pSample[i].y = y;
WiredHome 78:faf49c381591 3054 display.line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, Black);
WiredHome 78:faf49c381591 3055 display.line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, Black);
WiredHome 78:faf49c381591 3056 display.foreground(Blue);
WiredHome 78:faf49c381591 3057 display.printf(" (%4d,%4d)\r\n", x,y);
WiredHome 79:544eb4964795 3058 while (display.TouchPanelA2DFiltered(&x, &y))
WiredHome 78:faf49c381591 3059 wait_ms(20);
WiredHome 78:faf49c381591 3060 wait(2);
WiredHome 78:faf49c381591 3061 }
WiredHome 81:01da2e34283d 3062 display.TouchPanelComputeCalibration(pTest, pSample, &calmatrix);
WiredHome 78:faf49c381591 3063 display.printf(" Writing calibration to tpcal.cfg\r\n");
WiredHome 78:faf49c381591 3064 FILE * fh = fopen("/local/tpcal.cfg", "wb");
WiredHome 78:faf49c381591 3065 if (fh) {
WiredHome 78:faf49c381591 3066 fwrite(&calmatrix, sizeof(calmatrix), 1, fh);
WiredHome 78:faf49c381591 3067 fclose(fh);
WiredHome 78:faf49c381591 3068 }
WiredHome 78:faf49c381591 3069 display.printf(" Calibration is complete.");
WiredHome 78:faf49c381591 3070 } else if (c == 'r') {
WiredHome 78:faf49c381591 3071 display.printf(" Reading calibration from tpcal.cfg\r\n");
WiredHome 78:faf49c381591 3072 FILE * fh = fopen("/local/tpcal.cfg", "rb");
WiredHome 78:faf49c381591 3073 if (fh) {
WiredHome 78:faf49c381591 3074 fread(&calmatrix, sizeof(calmatrix), 1, fh);
WiredHome 78:faf49c381591 3075 fclose(fh);
WiredHome 78:faf49c381591 3076 }
WiredHome 78:faf49c381591 3077 display.printf(" Calibration is complete.");
WiredHome 78:faf49c381591 3078 display.TouchPanelSetMatrix(&calmatrix);
WiredHome 77:9206c13aa527 3079 }
WiredHome 77:9206c13aa527 3080 t.start();
WiredHome 77:9206c13aa527 3081 do {
WiredHome 77:9206c13aa527 3082 point_t point = {0, 0};
WiredHome 79:544eb4964795 3083 if (display.TouchPanelReadable(&point)) {
WiredHome 77:9206c13aa527 3084 display.pixel(point.x, point.y, Red);
WiredHome 77:9206c13aa527 3085 }
WiredHome 77:9206c13aa527 3086 } while (t.read_ms() < 30000);
WiredHome 77:9206c13aa527 3087 pc.printf(">");
WiredHome 77:9206c13aa527 3088 }
WiredHome 77:9206c13aa527 3089
WiredHome 77:9206c13aa527 3090
WiredHome 41:2956a0a221e5 3091 void SpeedTest(RA8875 & display, Serial & pc)
WiredHome 41:2956a0a221e5 3092 {
WiredHome 41:2956a0a221e5 3093 Timer t;
WiredHome 41:2956a0a221e5 3094 SuppressSlowStuff = true;
WiredHome 41:2956a0a221e5 3095 pc.printf("\r\nSpeedTest disables delays, runs tests, reports overall time.\r\n");
WiredHome 41:2956a0a221e5 3096 t.start();
WiredHome 41:2956a0a221e5 3097 // do stuff fast
WiredHome 41:2956a0a221e5 3098 TextCursorTest(display, pc);
WiredHome 49:c5182231d1b9 3099 TextWrapTest(display, pc);
WiredHome 41:2956a0a221e5 3100 BacklightTest(display, pc, 0);
WiredHome 41:2956a0a221e5 3101 BacklightTest2(display, pc);
WiredHome 41:2956a0a221e5 3102 ExternalFontTest(display, pc);
WiredHome 41:2956a0a221e5 3103 DOSColorTest(display, pc);
WiredHome 41:2956a0a221e5 3104 WebColorTest(display, pc);
WiredHome 41:2956a0a221e5 3105 PixelTest(display, pc);
WiredHome 41:2956a0a221e5 3106 LineTest(display, pc);
WiredHome 41:2956a0a221e5 3107 RectangleTest(display, pc);
WiredHome 41:2956a0a221e5 3108 RoundRectTest(display, pc);
WiredHome 41:2956a0a221e5 3109 TriangleTest(display, pc);
WiredHome 41:2956a0a221e5 3110 CircleTest(display, pc);
WiredHome 41:2956a0a221e5 3111 EllipseTest(display, pc);
WiredHome 44:207594dece70 3112 LayerTest(display, pc);
WiredHome 41:2956a0a221e5 3113 //TestGraphicsBitmap(display, pc);
WiredHome 41:2956a0a221e5 3114 pc.printf("SpeedTest completed in %d msec\r\n", t.read_ms());
WiredHome 73:f22a18707b5e 3115 #ifdef PERF_METRICS
WiredHome 41:2956a0a221e5 3116 display.ReportPerformance(pc);
WiredHome 73:f22a18707b5e 3117 #endif
WiredHome 41:2956a0a221e5 3118 SuppressSlowStuff = false;
WiredHome 41:2956a0a221e5 3119 }
WiredHome 41:2956a0a221e5 3120
WiredHome 44:207594dece70 3121
WiredHome 41:2956a0a221e5 3122 void PrintScreen(RA8875 & display, Serial & pc)
WiredHome 41:2956a0a221e5 3123 {
WiredHome 41:2956a0a221e5 3124 if (!SuppressSlowStuff)
WiredHome 73:f22a18707b5e 3125 pc.printf("PrintScreen\r\n");
WiredHome 41:2956a0a221e5 3126 display.PrintScreen( 0,0, 480,272, "/local/Capture.bmp");
WiredHome 41:2956a0a221e5 3127 }
WiredHome 41:2956a0a221e5 3128
WiredHome 44:207594dece70 3129
WiredHome 23:a50ded45dbaf 3130 void RunTestSet(RA8875 & lcd, Serial & pc)
WiredHome 23:a50ded45dbaf 3131 {
WiredHome 23:a50ded45dbaf 3132 int q = 0;
WiredHome 23:a50ded45dbaf 3133 int automode = 0;
WiredHome 49:c5182231d1b9 3134 const unsigned char modelist[] = "BDWtGLlFROTPCEbw"; // auto-test in this order.
WiredHome 23:a50ded45dbaf 3135
WiredHome 23:a50ded45dbaf 3136 while(1) {
WiredHome 23:a50ded45dbaf 3137 pc.printf("\r\n"
WiredHome 41:2956a0a221e5 3138 "B - Backlight up b - backlight dim\r\n"
WiredHome 41:2956a0a221e5 3139 "D - DOS Colors W - Web Colors\r\n"
WiredHome 41:2956a0a221e5 3140 "t - text cursor G - Graphics Bitmap\r\n"
WiredHome 41:2956a0a221e5 3141 "L - Lines F - external Font\r\n"
WiredHome 41:2956a0a221e5 3142 "R - Rectangles O - rOund rectangles\r\n"
WiredHome 41:2956a0a221e5 3143 "T - Triangles P - Pixels \r\n"
WiredHome 41:2956a0a221e5 3144 "C - Circles E - Ellipses\r\n"
WiredHome 41:2956a0a221e5 3145 "A - Auto Test mode S - Speed Test\r\n"
WiredHome 77:9206c13aa527 3146 "K - Keypad Test s - touch screen test\r\n"
WiredHome 41:2956a0a221e5 3147 "p - print screen r - reset \r\n"
WiredHome 49:c5182231d1b9 3148 "l - layer test w - wrapping text \r\n"
WiredHome 73:f22a18707b5e 3149 #ifdef PERF_METRICS
WiredHome 41:2956a0a221e5 3150 "0 - clear performance 1 - report performance\r\n"
WiredHome 73:f22a18707b5e 3151 #endif
WiredHome 23:a50ded45dbaf 3152 "> ");
WiredHome 23:a50ded45dbaf 3153 if (automode == -1 || pc.readable()) {
WiredHome 23:a50ded45dbaf 3154 automode = -1;
WiredHome 37:f19b7e7449dc 3155 q = pc.getc();
WiredHome 37:f19b7e7449dc 3156 while (pc.readable())
WiredHome 37:f19b7e7449dc 3157 pc.getc();
WiredHome 23:a50ded45dbaf 3158 } else if (automode >= 0) {
WiredHome 23:a50ded45dbaf 3159 q = modelist[automode];
WiredHome 23:a50ded45dbaf 3160 }
WiredHome 23:a50ded45dbaf 3161 switch(q) {
WiredHome 73:f22a18707b5e 3162 #ifdef PERF_METRICS
WiredHome 41:2956a0a221e5 3163 case '0':
WiredHome 41:2956a0a221e5 3164 lcd.ClearPerformance();
WiredHome 41:2956a0a221e5 3165 break;
WiredHome 41:2956a0a221e5 3166 case '1':
WiredHome 41:2956a0a221e5 3167 lcd.ReportPerformance(pc);
WiredHome 41:2956a0a221e5 3168 break;
WiredHome 73:f22a18707b5e 3169 #endif
WiredHome 23:a50ded45dbaf 3170 case 'A':
WiredHome 23:a50ded45dbaf 3171 automode = 0;
WiredHome 23:a50ded45dbaf 3172 break;
WiredHome 23:a50ded45dbaf 3173 case 'B':
WiredHome 41:2956a0a221e5 3174 BacklightTest(lcd, pc, 2);
WiredHome 23:a50ded45dbaf 3175 break;
WiredHome 23:a50ded45dbaf 3176 case 'b':
WiredHome 23:a50ded45dbaf 3177 BacklightTest2(lcd, pc);
WiredHome 23:a50ded45dbaf 3178 break;
WiredHome 23:a50ded45dbaf 3179 case 'D':
WiredHome 23:a50ded45dbaf 3180 DOSColorTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3181 break;
WiredHome 75:ca78388cfd77 3182 case 'K':
WiredHome 75:ca78388cfd77 3183 KeyPadTest(lcd, pc);
WiredHome 75:ca78388cfd77 3184 break;
WiredHome 23:a50ded45dbaf 3185 case 'W':
WiredHome 23:a50ded45dbaf 3186 WebColorTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3187 break;
WiredHome 23:a50ded45dbaf 3188 case 't':
WiredHome 23:a50ded45dbaf 3189 TextCursorTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3190 break;
WiredHome 49:c5182231d1b9 3191 case 'w':
WiredHome 49:c5182231d1b9 3192 TextWrapTest(lcd, pc);
WiredHome 49:c5182231d1b9 3193 break;
WiredHome 23:a50ded45dbaf 3194 case 'F':
WiredHome 23:a50ded45dbaf 3195 ExternalFontTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3196 break;
WiredHome 23:a50ded45dbaf 3197 case 'L':
WiredHome 23:a50ded45dbaf 3198 LineTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3199 break;
WiredHome 44:207594dece70 3200 case 'l':
WiredHome 44:207594dece70 3201 LayerTest(lcd, pc);
WiredHome 44:207594dece70 3202 break;
WiredHome 23:a50ded45dbaf 3203 case 'R':
WiredHome 23:a50ded45dbaf 3204 RectangleTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3205 break;
WiredHome 23:a50ded45dbaf 3206 case 'O':
WiredHome 23:a50ded45dbaf 3207 RoundRectTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3208 break;
WiredHome 41:2956a0a221e5 3209 case 'p':
WiredHome 41:2956a0a221e5 3210 PrintScreen(lcd, pc);
WiredHome 41:2956a0a221e5 3211 break;
WiredHome 41:2956a0a221e5 3212 case 'S':
WiredHome 41:2956a0a221e5 3213 SpeedTest(lcd, pc);
WiredHome 41:2956a0a221e5 3214 break;
WiredHome 77:9206c13aa527 3215 case 's':
WiredHome 77:9206c13aa527 3216 TouchPanelTest(lcd, pc);
WiredHome 77:9206c13aa527 3217 break;
WiredHome 23:a50ded45dbaf 3218 case 'T':
WiredHome 23:a50ded45dbaf 3219 TriangleTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3220 break;
WiredHome 37:f19b7e7449dc 3221 case 'P':
WiredHome 37:f19b7e7449dc 3222 PixelTest(lcd, pc);
WiredHome 37:f19b7e7449dc 3223 break;
WiredHome 37:f19b7e7449dc 3224 case 'G':
WiredHome 37:f19b7e7449dc 3225 TestGraphicsBitmap(lcd, pc);
WiredHome 37:f19b7e7449dc 3226 break;
WiredHome 23:a50ded45dbaf 3227 case 'C':
WiredHome 23:a50ded45dbaf 3228 CircleTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3229 break;
WiredHome 23:a50ded45dbaf 3230 case 'E':
WiredHome 23:a50ded45dbaf 3231 EllipseTest(lcd, pc);
WiredHome 23:a50ded45dbaf 3232 break;
WiredHome 23:a50ded45dbaf 3233 case 'r':
WiredHome 23:a50ded45dbaf 3234 pc.printf("Resetting ...\r\n");
WiredHome 23:a50ded45dbaf 3235 wait_ms(20);
WiredHome 23:a50ded45dbaf 3236 mbed_reset();
WiredHome 23:a50ded45dbaf 3237 break;
WiredHome 75:ca78388cfd77 3238 case ' ':
WiredHome 75:ca78388cfd77 3239 break;
WiredHome 23:a50ded45dbaf 3240 default:
WiredHome 23:a50ded45dbaf 3241 printf("huh?\n");
WiredHome 23:a50ded45dbaf 3242 break;
WiredHome 23:a50ded45dbaf 3243 }
WiredHome 23:a50ded45dbaf 3244 if (automode >= 0) {
WiredHome 23:a50ded45dbaf 3245 automode++;
WiredHome 23:a50ded45dbaf 3246 if (automode >= sizeof(modelist))
WiredHome 23:a50ded45dbaf 3247 automode = 0;
WiredHome 23:a50ded45dbaf 3248 wait_ms(2000);
WiredHome 23:a50ded45dbaf 3249 }
WiredHome 23:a50ded45dbaf 3250 wait_ms(200);
WiredHome 23:a50ded45dbaf 3251 }
WiredHome 23:a50ded45dbaf 3252 }
WiredHome 23:a50ded45dbaf 3253
WiredHome 79:544eb4964795 3254 #endif // TESTENABLE