David Smart / RA8875 Featured

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependents:   FRDM_RA8875_mPaint RA8875_Demo RA8875_KeyPadDemo SignalGenerator ... more

Fork of SPI_TFT by Peter Drescher

See Components - RA8875 Based Display

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

Offline Help Manual (Windows chm)

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

RA8875.cpp@202:a22cbc04f332, 2020-04-30 (annotated)

Committer:
WiredHome
Date:
Thu Apr 30 13:51:32 2020 +0000
Revision:
202:a22cbc04f332
Parent:
200:ae29b60d087c
Child:
203:704df2dbd3e6
Private max,min macros; avoid collision with other libs.; Correct jpg rendering defect; window() to SetWindow().; Coordinate translation for touch with orientation.; Added method; get rendered rect_t for string.; Fix for the reset pin option.;

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