Kerry Martin / RA8875

KSM edits to RA8875

Dependents:   Liz_Test_Code

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