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@145:5eb2492acdda, 2017-05-06 (annotated)

Committer:
WiredHome
Date:
Sat May 06 20:27:44 2017 +0000
Revision:
145:5eb2492acdda
Parent:
141:2ec78a50dc98
Child:
146:373d59f08357
hook the memory allocation to use a special instrumented allocation

Who changed what in which revision?

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