Luis Amell / RA8875

This is the David Smart RA8875 Library with mods for working with FRDM-K64F

RA8875.cpp@195:17e176dbd6eb, 2020-02-11 (annotated)

Committer:
WiredHome
Date:
Tue Feb 11 18:33:44 2020 +0000
Revision:
195:17e176dbd6eb
Parent:
194:53c18f0e7922
Child:
196:56820026701b
Working on orientation.

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