David Smart / RA8875 Featured

Library to control a Graphics TFT connected to 4-wire SPI - revised for the Raio RA8875 Display Controller.

Dependents:   FRDM_RA8875_mPaint RA8875_Demo RA8875_KeyPadDemo SignalGenerator ... more

Fork of SPI_TFT by Peter Drescher

See Components - RA8875 Based Display

Enhanced touch-screen support - where it previous supported both the Resistive Touch and Capacitive Touch based on the FT5206 Touch Controller, now it also has support for the GSL1680 Touch Controller.

Offline Help Manual (Windows chm)

/media/uploads/WiredHome/ra8875.zip.bin (download, rename to .zip and unzip)

RA8875.cpp@165:695c24cc5197, 2019-02-24 (annotated)

Committer:
WiredHome
Date:
Sun Feb 24 00:40:00 2019 +0000
Revision:
165:695c24cc5197
Parent:
164:76edd7d9cb68
Child:
166:53fd4a876dac
Initial refactoring to add support for another Cap Sense touch controller - based on the GSL1680.

Who changed what in which revision?

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