Kerry Martin / RA8875

KSM edits to RA8875

Dependents:   Liz_Test_Code

RA8875.cpp@142:6e9bff59878a, 2017-03-19 (annotated)

Committer:
WiredHome
Date:
Sun Mar 19 21:41:24 2017 +0000
Revision:
142:6e9bff59878a
Parent:
141:2ec78a50dc98
Child:
143:e872d65a710d
Breaking change on SelectDrawingLayer command, which now returns the previous layer (making it far easier to restore layers).

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