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@155:b3f225ae572c, 2018-11-13 (annotated)

Committer:
WiredHome
Date:
Tue Nov 13 01:33:41 2018 +0000
Revision:
155:b3f225ae572c
Parent:
154:ad2450fc3dc3
Child:
157:1565f38ca44b
use eventThread for newer OS5 in place of callbacks.; touch-cal timeout increased to 30s from 15.

Who changed what in which revision?

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