Kerry Martin / RA8875

KSM edits to RA8875

Dependents:   Liz_Test_Code

RA8875.cpp@133:e36dcfc2d756, 2016-10-17 (annotated)

Committer:
WiredHome
Date:
Mon Oct 17 00:42:47 2016 +0000
Revision:
133:e36dcfc2d756
Parent:
131:5bd6ba2ee4a1
Child:
134:f028ed71a0af
Revised how it sets the foreground and background color to correct a defect when in 8-bit mode.

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