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@172:7abb03bf31be, 2019-01-13 (annotated)

Committer:
WiredHome
Date:
Sun Jan 13 20:38:01 2019 +0000
Revision:
172:7abb03bf31be
Parent:
157:1565f38ca44b 
Non-functional refactoring

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