David Smart / RA8875 Featured

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

Dependents:   FRDM_RA8875_mPaint RA8875_Demo RA8875_KeyPadDemo SignalGenerator ... more

Fork of SPI_TFT by Peter Drescher

See Components - RA8875 Based Display

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

Offline Help Manual (Windows chm)

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

RA8875.cpp@72:ecffe56af969, 2014-10-11 (annotated)

Committer:
WiredHome
Date:
Sat Oct 11 17:24:29 2014 +0000
Revision:
72:ecffe56af969
Parent:
71:dcac8efd842d
Child:
73:f22a18707b5e
Documentation updates only.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
WiredHome 19:3f82c1161fd2 1 /// RA8875 Display Controller Library.
WiredHome 19:3f82c1161fd2 2 ///
WiredHome 68:ab08efabfc88 3 /// This is being created for a Raio RA8875-based display from buydisplay.com,
WiredHome 68:ab08efabfc88 4 /// which is 480 x 272 using a 4-wire SPI interface.
WiredHome 68:ab08efabfc88 5 /// This display controller is used in other display resolutions, up to 800x600.
WiredHome 68:ab08efabfc88 6 /// While this driver has not been tested with these variants, nothing was done
WiredHome 68:ab08efabfc88 7 /// to prevent easily supporting them.
WiredHome 19:3f82c1161fd2 8 ///
WiredHome 19:3f82c1161fd2 9 #include "RA8875.h"
WiredHome 19:3f82c1161fd2 10
WiredHome 41:2956a0a221e5 11 //#define DEBUG "RAIO"
WiredHome 19:3f82c1161fd2 12 // ...
WiredHome 19:3f82c1161fd2 13 // INFO("Stuff to show %d", var); // new-line is automatically appended
WiredHome 19:3f82c1161fd2 14 //
WiredHome 19:3f82c1161fd2 15 #if (defined(DEBUG) && !defined(TARGET_LPC11U24))
WiredHome 19:3f82c1161fd2 16 #define INFO(x, ...) std::printf("[INF %s %3d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome 19:3f82c1161fd2 17 #define WARN(x, ...) std::printf("[WRN %s %3d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome 19:3f82c1161fd2 18 #define ERR(x, ...) std::printf("[ERR %s %3d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome 19:3f82c1161fd2 19 #else
WiredHome 19:3f82c1161fd2 20 #define INFO(x, ...)
WiredHome 19:3f82c1161fd2 21 #define WARN(x, ...)
WiredHome 19:3f82c1161fd2 22 #define ERR(x, ...)
WiredHome 19:3f82c1161fd2 23 #endif
WiredHome 19:3f82c1161fd2 24
WiredHome 19:3f82c1161fd2 25
WiredHome 19:3f82c1161fd2 26 #define RA8875_DISPLAY_WIDTH 480
WiredHome 19:3f82c1161fd2 27 #define RA8875_DISPLAY_HEIGHT 272
WiredHome 43:3becae133285 28 #define RA8875_COLORDEPTH_BPP 16 /* Not an API */
WiredHome 19:3f82c1161fd2 29
WiredHome 19:3f82c1161fd2 30 #ifdef PERF_METRICS
WiredHome 19:3f82c1161fd2 31 #define PERFORMANCE_RESET performance.reset()
WiredHome 19:3f82c1161fd2 32 #define REGISTERPERFORMANCE(a) RegisterPerformance(a)
WiredHome 68:ab08efabfc88 33 #define COUNTIDLETIME(a) CountIdleTime(a)
WiredHome 19:3f82c1161fd2 34 static const char *metricsName[] =
WiredHome 19:3f82c1161fd2 35 {
WiredHome 41:2956a0a221e5 36 "Cls", "Pixel", "Pixel Stream",
WiredHome 41:2956a0a221e5 37 "Read Pixel", "Read Pixel Stream",
WiredHome 41:2956a0a221e5 38 "Line",
WiredHome 68:ab08efabfc88 39 "Rectangle", "Rounded Rectangle",
WiredHome 68:ab08efabfc88 40 "Triangle", "Circle", "Ellipse"
WiredHome 19:3f82c1161fd2 41 };
WiredHome 19:3f82c1161fd2 42 #else
WiredHome 19:3f82c1161fd2 43 #define PERFORMANCE_RESET
WiredHome 19:3f82c1161fd2 44 #define REGISTERPERFORMANCE(a)
WiredHome 68:ab08efabfc88 45 #define COUNTIDLETIME(a)
WiredHome 19:3f82c1161fd2 46 #endif
WiredHome 19:3f82c1161fd2 47
WiredHome 19:3f82c1161fd2 48 // When it is going to poll a register for completion, how many
WiredHome 19:3f82c1161fd2 49 // uSec should it wait between each polling activity.
WiredHome 19:3f82c1161fd2 50 #define POLLWAITuSec 10
WiredHome 19:3f82c1161fd2 51
WiredHome 19:3f82c1161fd2 52
WiredHome 19:3f82c1161fd2 53 RA8875::RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset, const char *name)
WiredHome 58:26658a56112a 54 : GraphicsDisplay(name)
WiredHome 58:26658a56112a 55 , spi(mosi, miso, sclk)
WiredHome 19:3f82c1161fd2 56 , cs(csel)
WiredHome 19:3f82c1161fd2 57 , res(reset)
WiredHome 19:3f82c1161fd2 58 {
WiredHome 19:3f82c1161fd2 59 font = NULL; // no external font, use internal.
WiredHome 19:3f82c1161fd2 60 select(false); // deselect the display
WiredHome 19:3f82c1161fd2 61 frequency(RA8875_DEFAULT_SPI_FREQ); // data rate
WiredHome 28:ed102fc442c4 62 Reset();
WiredHome 28:ed102fc442c4 63 Power(true);
WiredHome 28:ed102fc442c4 64 Backlight_u8(255);
WiredHome 19:3f82c1161fd2 65 #ifdef PERF_METRICS
WiredHome 19:3f82c1161fd2 66 performance.start();
WiredHome 19:3f82c1161fd2 67 ClearPerformance();
WiredHome 19:3f82c1161fd2 68 #endif
WiredHome 19:3f82c1161fd2 69 }
WiredHome 19:3f82c1161fd2 70
WiredHome 43:3becae133285 71
WiredHome 19:3f82c1161fd2 72 //RA8875::~RA8875()
WiredHome 19:3f82c1161fd2 73 //{
WiredHome 19:3f82c1161fd2 74 //}
WiredHome 19:3f82c1161fd2 75
WiredHome 61:8f3153bf0baa 76 uint16_t RA8875::GetDrawingLayer(void)
WiredHome 61:8f3153bf0baa 77 {
WiredHome 61:8f3153bf0baa 78 return (ReadCommand(0x41) & 0x01);
WiredHome 61:8f3153bf0baa 79 }
WiredHome 43:3becae133285 80
WiredHome 50:2c4f474a2453 81 RetCode_t RA8875::SelectDrawingLayer(uint16_t layer)
WiredHome 43:3becae133285 82 {
WiredHome 43:3becae133285 83 unsigned char mwcr1 = ReadCommand(0x41) & ~0x01; // retain all but the currently selected layer
WiredHome 43:3becae133285 84
WiredHome 43:3becae133285 85 if (width() >= 800 && height() >= 480 && color_bpp() == 8) {
WiredHome 43:3becae133285 86 return bad_parameter;
WiredHome 43:3becae133285 87 } else if (layer > 1) {
WiredHome 43:3becae133285 88 return bad_parameter;
WiredHome 43:3becae133285 89 } else { // layer == 0 ro 1
WiredHome 72:ecffe56af969 90 return WriteCommand(0x41, mwcr1 | layer);
WiredHome 43:3becae133285 91 }
WiredHome 43:3becae133285 92 }
WiredHome 43:3becae133285 93
WiredHome 44:207594dece70 94
WiredHome 53:86d24b9480b9 95 RetCode_t RA8875::SetLayerMode(LayerMode_T mode)
WiredHome 44:207594dece70 96 {
WiredHome 53:86d24b9480b9 97 unsigned char ltpr0 = ReadCommand(0x52) & ~0x7; // retain all but the display layer mode
WiredHome 53:86d24b9480b9 98 if (mode <= (LayerMode_T)6) {
WiredHome 53:86d24b9480b9 99 WriteCommand(0x52, ltpr0 | (mode & 0x7));
WiredHome 53:86d24b9480b9 100 return noerror;
WiredHome 53:86d24b9480b9 101 } else {
WiredHome 53:86d24b9480b9 102 return bad_parameter;
WiredHome 53:86d24b9480b9 103 }
WiredHome 44:207594dece70 104 }
WiredHome 44:207594dece70 105
WiredHome 44:207594dece70 106
WiredHome 44:207594dece70 107 RetCode_t RA8875::SetLayerTransparency(uint8_t layer1, uint8_t layer2)
WiredHome 44:207594dece70 108 {
WiredHome 44:207594dece70 109 if (layer1 > 8)
WiredHome 44:207594dece70 110 layer1 = 8;
WiredHome 44:207594dece70 111 if (layer2 > 8)
WiredHome 44:207594dece70 112 layer2 = 8;
WiredHome 44:207594dece70 113 WriteCommand(0x53, ((layer2 & 0xF) << 4) | (layer1 & 0xF));
WiredHome 44:207594dece70 114 return noerror;
WiredHome 44:207594dece70 115 }
WiredHome 44:207594dece70 116
WiredHome 44:207594dece70 117
WiredHome 53:86d24b9480b9 118 RetCode_t RA8875::SetBackgroundTransparencyColor(color_t color)
WiredHome 53:86d24b9480b9 119 {
WiredHome 53:86d24b9480b9 120 WriteCommand(0x67, (color >> 11) & 0x1F);
WiredHome 53:86d24b9480b9 121 WriteCommand(0x68, (color >> 5) & 0x3F);
WiredHome 53:86d24b9480b9 122 WriteCommand(0x69, (color & 0x1F));
WiredHome 53:86d24b9480b9 123 return noerror;
WiredHome 53:86d24b9480b9 124 }
WiredHome 53:86d24b9480b9 125
hexley 54:e117ad10fba6 126 // ### Touch Panel support code additions begin here
hexley 54:e117ad10fba6 127
hexley 54:e117ad10fba6 128 RetCode_t RA8875::TouchPanelInit(void)
hexley 54:e117ad10fba6 129 {
hexley 54:e117ad10fba6 130 //TPCR0: Set enable bit, default sample time, wakeup, and ADC clock
hexley 54:e117ad10fba6 131 WriteCommand(TPCR0, TP_ENABLE | TP_ADC_SAMPLE_DEFAULT_CLKS | TP_ADC_CLKDIV_DEFAULT);
hexley 54:e117ad10fba6 132 // TPCR1: Set auto/manual, Ref voltage, debounce, manual mode params
hexley 54:e117ad10fba6 133 WriteCommand(TPCR1, TP_MODE_DEFAULT | TP_DEBOUNCE_DEFAULT);
hexley 54:e117ad10fba6 134 WriteCommand(INTC1, ReadCommand(INTC1) | RA8875_INT_TP); // reg INTC1: Enable Touch Panel Interrupts (D2 = 1)
hexley 54:e117ad10fba6 135 WriteCommand(INTC2, RA8875_INT_TP); // reg INTC2: Clear any TP interrupt flag
hexley 54:e117ad10fba6 136 return noerror;
hexley 54:e117ad10fba6 137 }
hexley 54:e117ad10fba6 138
hexley 54:e117ad10fba6 139 RetCode_t RA8875::TouchPanelInit(uint8_t bTpEnable, uint8_t bTpAutoManual, uint8_t bTpDebounce, uint8_t bTpManualMode, uint8_t bTpAdcClkDiv, uint8_t bTpAdcSampleTime)
hexley 54:e117ad10fba6 140 {
hexley 54:e117ad10fba6 141 // Parameter bounds check
hexley 54:e117ad10fba6 142 if( \
hexley 54:e117ad10fba6 143 !(bTpEnable == TP_ENABLE || bTpEnable == TP_ENABLE) || \
hexley 54:e117ad10fba6 144 !(bTpAutoManual == TP_MODE_AUTO || bTpAutoManual == TP_MODE_MANUAL) || \
hexley 54:e117ad10fba6 145 !(bTpDebounce == TP_DEBOUNCE_OFF || bTpDebounce == TP_DEBOUNCE_ON) || \
hexley 54:e117ad10fba6 146 !(bTpManualMode <= TP_MANUAL_LATCH_Y) || \
hexley 54:e117ad10fba6 147 !(bTpAdcClkDiv <= TP_ADC_CLKDIV_128) || \
hexley 54:e117ad10fba6 148 !(bTpAdcSampleTime <= TP_ADC_SAMPLE_65536_CLKS) \
hexley 54:e117ad10fba6 149 ) return bad_parameter;
hexley 54:e117ad10fba6 150 // Construct the config byte for TPCR0 and write them
hexley 54:e117ad10fba6 151 WriteCommand(TPCR0, bTpEnable | bTpAdcClkDiv | bTpAdcSampleTime); // Note: Wakeup is never enabled
hexley 54:e117ad10fba6 152 // Construct the config byte for TPCR1 and write them
hexley 54:e117ad10fba6 153 WriteCommand(TPCR1, bTpManualMode | bTpDebounce | bTpManualMode); // Note: Always uses internal Vref.
hexley 54:e117ad10fba6 154 // Set up the interrupt flag and enable bits
hexley 54:e117ad10fba6 155 WriteCommand(INTC1, ReadCommand(INTC1) | RA8875_INT_TP); // reg INTC1: Enable Touch Panel Interrupts (D2 = 1)
hexley 54:e117ad10fba6 156 WriteCommand(INTC2, RA8875_INT_TP); // reg INTC2: Clear any TP interrupt flag
hexley 54:e117ad10fba6 157 return noerror;
hexley 54:e117ad10fba6 158 }
hexley 54:e117ad10fba6 159
hexley 54:e117ad10fba6 160 unsigned char RA8875::TouchPanelRead(loc_t *x, loc_t *y)
hexley 54:e117ad10fba6 161 {
hexley 54:e117ad10fba6 162 unsigned char touchready;
hexley 54:e117ad10fba6 163 static int xbuf[TPBUFSIZE], ybuf[TPBUFSIZE], sample = 0;
hexley 54:e117ad10fba6 164 int i, j, temp;
hexley 54:e117ad10fba6 165
hexley 54:e117ad10fba6 166 if( (ReadCommand(INTC2) & RA8875_INT_TP) ) { // Test for TP Interrupt pending in register INTC2
hexley 54:e117ad10fba6 167 // Get the next data samples
hexley 54:e117ad10fba6 168 ybuf[sample] = ReadCommand(TPYH) << 2 | ( (ReadCommand(TPXYL) & 0xC) >> 2 ); // D[9:2] from reg TPYH, D[1:0] from reg TPXYL[3:2]
hexley 54:e117ad10fba6 169 xbuf[sample] = ReadCommand(TPXH) << 2 | ( (ReadCommand(TPXYL) & 0x3) ); // D[9:2] from reg TPXH, D[1:0] from reg TPXYL[1:0]
hexley 54:e117ad10fba6 170 // Check for a complete set
hexley 54:e117ad10fba6 171 if(++sample == TPBUFSIZE) {
hexley 54:e117ad10fba6 172 // Buffers are full, so process them using Finn's method described in Analog Dialogue No. 44, Feb 2010
hexley 54:e117ad10fba6 173 // This requires sorting the samples in order of size, then discarding the top 25% and
hexley 54:e117ad10fba6 174 // bottom 25% as noise spikes. Finally, the middle 50% of the values are averaged to
hexley 54:e117ad10fba6 175 // reduce Gaussian noise.
hexley 54:e117ad10fba6 176
hexley 54:e117ad10fba6 177 // Sort the Y buffer using an Insertion Sort
hexley 54:e117ad10fba6 178 for(i = 1; i <= TPBUFSIZE; i++) {
hexley 54:e117ad10fba6 179 temp = ybuf[i];
hexley 54:e117ad10fba6 180 j = i;
hexley 54:e117ad10fba6 181 while( j && (ybuf[j-1] > temp) ) {
hexley 54:e117ad10fba6 182 ybuf[j] = ybuf[j-1];
hexley 54:e117ad10fba6 183 j = j-1;
hexley 54:e117ad10fba6 184 }
hexley 54:e117ad10fba6 185 ybuf[j] = temp;
hexley 54:e117ad10fba6 186 } // End of Y sort
hexley 54:e117ad10fba6 187 // Sort the X buffer the same way
hexley 54:e117ad10fba6 188 for(i = 1; i <= TPBUFSIZE; i++) {
hexley 54:e117ad10fba6 189 temp = xbuf[i];
hexley 54:e117ad10fba6 190 j = i;
hexley 54:e117ad10fba6 191 while( j && (xbuf[j-1] > temp) ) {
hexley 54:e117ad10fba6 192 xbuf[j] = xbuf[j-1];
hexley 54:e117ad10fba6 193 j = j-1;
hexley 54:e117ad10fba6 194 }
hexley 54:e117ad10fba6 195 xbuf[j] = temp;
hexley 54:e117ad10fba6 196 } // End of X sort
hexley 54:e117ad10fba6 197 // Average the middle half of the Y values and report them
hexley 54:e117ad10fba6 198 j = 0;
hexley 54:e117ad10fba6 199 for(i = (TPBUFSIZE/4) - 1; i < TPBUFSIZE - TPBUFSIZE/4; i++ ) {
hexley 54:e117ad10fba6 200 j += ybuf[i];
hexley 54:e117ad10fba6 201 }
hexley 54:e117ad10fba6 202 *y = j * (float)2/TPBUFSIZE; // This is the average
hexley 54:e117ad10fba6 203 // Average the middle half of the X values and report them
hexley 54:e117ad10fba6 204 j = 0;
hexley 54:e117ad10fba6 205 for(i = (TPBUFSIZE/4) - 1; i < TPBUFSIZE - TPBUFSIZE/4; i++ ) {
hexley 54:e117ad10fba6 206 j += xbuf[i];
hexley 54:e117ad10fba6 207 }
hexley 54:e117ad10fba6 208 *x = j * (float)2/TPBUFSIZE; // This is the average
hexley 54:e117ad10fba6 209 // Tidy up and return
hexley 54:e117ad10fba6 210 touchready = 1;
hexley 54:e117ad10fba6 211 sample = 0; // Ready to start on the next set of data samples
hexley 54:e117ad10fba6 212 }
hexley 54:e117ad10fba6 213 else {
hexley 54:e117ad10fba6 214 // Buffer not yet full, so do not return any results yet
hexley 54:e117ad10fba6 215 touchready = 0;
hexley 54:e117ad10fba6 216 }
hexley 54:e117ad10fba6 217 WriteCommand(INTC2, RA8875_INT_TP); // reg INTC2: Clear that TP interrupt flag
hexley 54:e117ad10fba6 218 } // End of initial if -- data has been read and processed
hexley 54:e117ad10fba6 219 else
hexley 54:e117ad10fba6 220 touchready = 0; // Touch Panel "Int" was not set
hexley 54:e117ad10fba6 221 return touchready;
hexley 54:e117ad10fba6 222 }
hexley 54:e117ad10fba6 223
hexley 54:e117ad10fba6 224 unsigned char RA8875::TouchPanelReadRaw(loc_t *x, loc_t *y)
hexley 54:e117ad10fba6 225 {
hexley 54:e117ad10fba6 226 unsigned char touchready;
hexley 54:e117ad10fba6 227
hexley 54:e117ad10fba6 228 if( (ReadCommand(INTC2) & RA8875_INT_TP) ) { // Test for TP Interrupt pending in register INTC2
hexley 54:e117ad10fba6 229 *y = ReadCommand(TPYH) << 2 | ( (ReadCommand(TPXYL) & 0xC) >> 2 ); // D[9:2] from reg TPYH, D[1:0] from reg TPXYL[3:2]
hexley 54:e117ad10fba6 230 *x = ReadCommand(TPXH) << 2 | ( (ReadCommand(TPXYL) & 0x3) ); // D[9:2] from reg TPXH, D[1:0] from reg TPXYL[1:0]
hexley 54:e117ad10fba6 231 WriteCommand(INTC2, RA8875_INT_TP); // reg INTC2: Clear that TP interrupt flag
hexley 54:e117ad10fba6 232 touchready = 1;
hexley 54:e117ad10fba6 233 }
hexley 54:e117ad10fba6 234 else
hexley 54:e117ad10fba6 235 touchready = 0;
hexley 54:e117ad10fba6 236 return touchready;
hexley 54:e117ad10fba6 237 }
hexley 54:e117ad10fba6 238 // #### end of touch panel code additions
WiredHome 53:86d24b9480b9 239
WiredHome 71:dcac8efd842d 240
WiredHome 71:dcac8efd842d 241 RetCode_t RA8875::KeypadInit(bool scanEnable, bool longDetect, uint8_t sampleTime, uint8_t scanFrequency,
WiredHome 71:dcac8efd842d 242 uint8_t longTimeAdjustment, bool interruptEnable, bool wakeupEnable)
WiredHome 71:dcac8efd842d 243 {
WiredHome 71:dcac8efd842d 244 uint8_t value = 0;
WiredHome 71:dcac8efd842d 245
WiredHome 71:dcac8efd842d 246 if (sampleTime > 3 || scanFrequency > 7 || longTimeAdjustment > 3)
WiredHome 71:dcac8efd842d 247 return bad_parameter;
WiredHome 71:dcac8efd842d 248 value |= (scanEnable) ? 0x80 : 0x00;
WiredHome 71:dcac8efd842d 249 value |= (longDetect) ? 0x40 : 0x00;
WiredHome 71:dcac8efd842d 250 value |= (sampleTime & 0x03) << 4;
WiredHome 71:dcac8efd842d 251 value |= (scanFrequency & 0x07);
WiredHome 71:dcac8efd842d 252 WriteCommand(0xC0, value); // Enable Key Scan (and ignore possibility of an error)
WiredHome 71:dcac8efd842d 253
WiredHome 71:dcac8efd842d 254 value = 0;
WiredHome 71:dcac8efd842d 255 value |= (wakeupEnable) ? 0x80 : 0x00;
WiredHome 71:dcac8efd842d 256 value |= (longTimeAdjustment & 0x03) << 2;
WiredHome 71:dcac8efd842d 257 WriteCommand(0xC1, value); // (and ignore possibility of an error)
WiredHome 71:dcac8efd842d 258
WiredHome 71:dcac8efd842d 259 value = ReadCommand(0xF0); // (and ignore possibility of an error)
WiredHome 71:dcac8efd842d 260 value &= ~0x10;
WiredHome 71:dcac8efd842d 261 value |= (interruptEnable) ? 0x10 : 0x00;
WiredHome 71:dcac8efd842d 262 return WriteCommand(0xF0, value);
WiredHome 71:dcac8efd842d 263 }
WiredHome 71:dcac8efd842d 264
WiredHome 71:dcac8efd842d 265 bool RA8875::_kbhit(void)
WiredHome 71:dcac8efd842d 266 {
WiredHome 71:dcac8efd842d 267 return (ReadCommand(0xF1) & 0x10); // check KS status - true if kbhit
WiredHome 71:dcac8efd842d 268 }
WiredHome 71:dcac8efd842d 269
WiredHome 71:dcac8efd842d 270 uint8_t RA8875::_getch(void)
WiredHome 71:dcac8efd842d 271 {
WiredHome 71:dcac8efd842d 272 while (!_kbhit()) {
WiredHome 71:dcac8efd842d 273 wait_us(POLLWAITuSec);
WiredHome 71:dcac8efd842d 274 COUNTIDLETIME(POLLWAITuSec);
WiredHome 71:dcac8efd842d 275 }
WiredHome 71:dcac8efd842d 276
WiredHome 71:dcac8efd842d 277 // read the key press number
WiredHome 71:dcac8efd842d 278 uint8_t keyNumReg = ReadCommand(0xC1) & 0x03;
WiredHome 71:dcac8efd842d 279 // read the key code
WiredHome 71:dcac8efd842d 280 uint8_t keyCode = ReadCommand(0xC2 + keyNumReg);
WiredHome 71:dcac8efd842d 281 // Clear KS status
WiredHome 71:dcac8efd842d 282 WriteCommand(0xF1, 0x10);
WiredHome 71:dcac8efd842d 283 return keyCode;
WiredHome 71:dcac8efd842d 284 }
WiredHome 71:dcac8efd842d 285
WiredHome 19:3f82c1161fd2 286 #ifdef PERF_METRICS
WiredHome 19:3f82c1161fd2 287 void RA8875::ClearPerformance()
WiredHome 19:3f82c1161fd2 288 {
WiredHome 19:3f82c1161fd2 289 for (int i=0; i<METRICCOUNT; i++)
WiredHome 19:3f82c1161fd2 290 metrics[i] = 0;
WiredHome 66:468a11f05580 291 idlecounter = 0;
WiredHome 19:3f82c1161fd2 292 }
WiredHome 19:3f82c1161fd2 293
WiredHome 19:3f82c1161fd2 294 void RA8875::RegisterPerformance(method_e method)
WiredHome 19:3f82c1161fd2 295 {
WiredHome 19:3f82c1161fd2 296 unsigned long elapsed = performance.read_us();
WiredHome 19:3f82c1161fd2 297
WiredHome 19:3f82c1161fd2 298 if (method < METRICCOUNT && elapsed > metrics[method])
WiredHome 19:3f82c1161fd2 299 metrics[method] = elapsed;
WiredHome 19:3f82c1161fd2 300 }
WiredHome 19:3f82c1161fd2 301
WiredHome 66:468a11f05580 302 void RA8875::CountIdleTime(uint32_t t)
WiredHome 66:468a11f05580 303 {
WiredHome 66:468a11f05580 304 idlecounter += t;
WiredHome 66:468a11f05580 305 }
WiredHome 44:207594dece70 306
WiredHome 41:2956a0a221e5 307 void RA8875::ReportPerformance(Serial & pc)
WiredHome 19:3f82c1161fd2 308 {
WiredHome 41:2956a0a221e5 309 pc.printf("\r\nPerformance Metrics\r\n");
WiredHome 19:3f82c1161fd2 310 for (int i=0; i<METRICCOUNT; i++) {
WiredHome 41:2956a0a221e5 311 pc.printf("%10d uS %s\r\n", metrics[i], metricsName[i]);
WiredHome 66:468a11f05580 312 }
WiredHome 68:ab08efabfc88 313 pc.printf("%10d uS Idle time polling display for ready.\r\n", idlecounter);
WiredHome 19:3f82c1161fd2 314 }
WiredHome 19:3f82c1161fd2 315 #endif
WiredHome 19:3f82c1161fd2 316
WiredHome 44:207594dece70 317
WiredHome 38:38d503b4fad6 318 RetCode_t RA8875::WriteCommandW(uint8_t command, uint16_t data)
WiredHome 38:38d503b4fad6 319 {
WiredHome 38:38d503b4fad6 320 #if 1
WiredHome 38:38d503b4fad6 321 WriteCommand(command, data & 0xFF);
WiredHome 38:38d503b4fad6 322 WriteCommand(command+1, data >> 8);
WiredHome 38:38d503b4fad6 323 #else
WiredHome 41:2956a0a221e5 324 // This should be a little faster, but doesn't work...
WiredHome 38:38d503b4fad6 325 INFO("WriteCommandW(%02X, %04X)", command, data);
WiredHome 38:38d503b4fad6 326 select(true);
WiredHome 38:38d503b4fad6 327 spiwrite(0x80);
WiredHome 38:38d503b4fad6 328 spiwrite(command);
WiredHome 41:2956a0a221e5 329 //spiwrite(0x00); // dummy
WiredHome 38:38d503b4fad6 330 spiwrite(data & 0xFF);
WiredHome 38:38d503b4fad6 331 spiwrite(data >> 8);
WiredHome 38:38d503b4fad6 332 select(false);
WiredHome 38:38d503b4fad6 333 #endif
WiredHome 38:38d503b4fad6 334 return noerror;
WiredHome 38:38d503b4fad6 335 }
WiredHome 38:38d503b4fad6 336
WiredHome 44:207594dece70 337
WiredHome 19:3f82c1161fd2 338 RetCode_t RA8875::WriteCommand(unsigned char command, unsigned int data)
WiredHome 19:3f82c1161fd2 339 {
WiredHome 19:3f82c1161fd2 340 select(true);
WiredHome 41:2956a0a221e5 341 spiwrite(0x80); // cmd: write command
WiredHome 19:3f82c1161fd2 342 spiwrite(command);
WiredHome 19:3f82c1161fd2 343 if (data <= 0xFF) { // only if in the valid range
WiredHome 19:3f82c1161fd2 344 spiwrite(0x00);
WiredHome 19:3f82c1161fd2 345 spiwrite(data);
WiredHome 19:3f82c1161fd2 346 }
WiredHome 19:3f82c1161fd2 347 select(false);
WiredHome 19:3f82c1161fd2 348 return noerror;
WiredHome 19:3f82c1161fd2 349 }
WiredHome 19:3f82c1161fd2 350
WiredHome 44:207594dece70 351
WiredHome 38:38d503b4fad6 352 RetCode_t RA8875::WriteDataW(uint16_t data)
WiredHome 38:38d503b4fad6 353 {
WiredHome 38:38d503b4fad6 354 select(true);
WiredHome 41:2956a0a221e5 355 spiwrite(0x00); // cmd: write data
WiredHome 38:38d503b4fad6 356 spiwrite(data & 0xFF);
WiredHome 38:38d503b4fad6 357 spiwrite(data >> 8);
WiredHome 38:38d503b4fad6 358 select(false);
WiredHome 38:38d503b4fad6 359 return noerror;
WiredHome 38:38d503b4fad6 360 }
WiredHome 38:38d503b4fad6 361
WiredHome 44:207594dece70 362
WiredHome 19:3f82c1161fd2 363 RetCode_t RA8875::WriteData(unsigned char data)
WiredHome 19:3f82c1161fd2 364 {
WiredHome 19:3f82c1161fd2 365 select(true);
WiredHome 19:3f82c1161fd2 366 spiwrite(0x00);
WiredHome 19:3f82c1161fd2 367 spiwrite(data);
WiredHome 19:3f82c1161fd2 368 select(false);
WiredHome 19:3f82c1161fd2 369 return noerror;
WiredHome 19:3f82c1161fd2 370 }
WiredHome 19:3f82c1161fd2 371
WiredHome 44:207594dece70 372
WiredHome 19:3f82c1161fd2 373 unsigned char RA8875::ReadCommand(unsigned char command)
WiredHome 19:3f82c1161fd2 374 {
WiredHome 19:3f82c1161fd2 375 WriteCommand(command);
WiredHome 19:3f82c1161fd2 376 return ReadData();
WiredHome 19:3f82c1161fd2 377 }
WiredHome 19:3f82c1161fd2 378
WiredHome 44:207594dece70 379
WiredHome 19:3f82c1161fd2 380 unsigned char RA8875::ReadData(void)
WiredHome 19:3f82c1161fd2 381 {
WiredHome 19:3f82c1161fd2 382 unsigned char data;
WiredHome 19:3f82c1161fd2 383
WiredHome 19:3f82c1161fd2 384 select(true);
WiredHome 19:3f82c1161fd2 385 spiwrite(0x40);
WiredHome 19:3f82c1161fd2 386 data = spiread();
WiredHome 19:3f82c1161fd2 387 select(false);
WiredHome 19:3f82c1161fd2 388 return data;
WiredHome 19:3f82c1161fd2 389 }
WiredHome 19:3f82c1161fd2 390
WiredHome 44:207594dece70 391
WiredHome 41:2956a0a221e5 392 uint16_t RA8875::ReadDataW(void)
WiredHome 41:2956a0a221e5 393 {
WiredHome 41:2956a0a221e5 394 uint16_t data;
WiredHome 41:2956a0a221e5 395
WiredHome 41:2956a0a221e5 396 select(true);
WiredHome 41:2956a0a221e5 397 spiwrite(0x40);
WiredHome 41:2956a0a221e5 398 data = spiread();
WiredHome 41:2956a0a221e5 399 data |= (spiread() << 8);
WiredHome 41:2956a0a221e5 400 select(false);
WiredHome 41:2956a0a221e5 401 return data;
WiredHome 41:2956a0a221e5 402 }
WiredHome 41:2956a0a221e5 403
WiredHome 44:207594dece70 404
WiredHome 19:3f82c1161fd2 405 unsigned char RA8875::ReadStatus(void)
WiredHome 19:3f82c1161fd2 406 {
WiredHome 19:3f82c1161fd2 407 unsigned char data;
WiredHome 19:3f82c1161fd2 408
WiredHome 19:3f82c1161fd2 409 select(true);
WiredHome 66:468a11f05580 410 spiwrite(0xC0); // These two bits are for the special "Status Read" [STSR]
WiredHome 19:3f82c1161fd2 411 data = spiread();
WiredHome 19:3f82c1161fd2 412 select(false);
WiredHome 19:3f82c1161fd2 413 return data;
WiredHome 19:3f82c1161fd2 414 }
WiredHome 19:3f82c1161fd2 415
WiredHome 66:468a11f05580 416 /// @todo add a timeout and return false, but how long
WiredHome 66:468a11f05580 417 /// to wait since some operations can be very long.
WiredHome 66:468a11f05580 418 bool RA8875::_WaitWhileBusy(uint8_t mask)
WiredHome 66:468a11f05580 419 {
WiredHome 66:468a11f05580 420 int i = 20000/POLLWAITuSec; // 20 msec max
WiredHome 66:468a11f05580 421
WiredHome 67:9f834f0ff97d 422 while (i-- && ReadStatus() & mask) {
WiredHome 66:468a11f05580 423 wait_us(POLLWAITuSec);
WiredHome 68:ab08efabfc88 424 COUNTIDLETIME(POLLWAITuSec);
WiredHome 67:9f834f0ff97d 425 }
WiredHome 66:468a11f05580 426 if (i)
WiredHome 66:468a11f05580 427 return true;
WiredHome 66:468a11f05580 428 else
WiredHome 66:468a11f05580 429 return false;
WiredHome 66:468a11f05580 430 }
WiredHome 66:468a11f05580 431
WiredHome 66:468a11f05580 432 /// @todo add a timeout and return false, but how long
WiredHome 66:468a11f05580 433 /// to wait since some operations can be very long.
WiredHome 66:468a11f05580 434 bool RA8875::_WaitWhileReg(uint8_t reg, uint8_t mask)
WiredHome 66:468a11f05580 435 {
WiredHome 66:468a11f05580 436 int i = 20000/POLLWAITuSec; // 20 msec max
WiredHome 66:468a11f05580 437
WiredHome 67:9f834f0ff97d 438 while (i-- && ReadCommand(reg) & mask) {
WiredHome 66:468a11f05580 439 wait_us(POLLWAITuSec);
WiredHome 68:ab08efabfc88 440 COUNTIDLETIME(POLLWAITuSec);
WiredHome 67:9f834f0ff97d 441 }
WiredHome 66:468a11f05580 442 if (i)
WiredHome 66:468a11f05580 443 return true;
WiredHome 66:468a11f05580 444 else
WiredHome 66:468a11f05580 445 return false;
WiredHome 66:468a11f05580 446 }
WiredHome 66:468a11f05580 447
WiredHome 66:468a11f05580 448
WiredHome 44:207594dece70 449
WiredHome 37:f19b7e7449dc 450 dim_t RA8875::fontwidth(void)
WiredHome 19:3f82c1161fd2 451 {
WiredHome 19:3f82c1161fd2 452 if (font == NULL)
WiredHome 55:dfbabef7003e 453 return (((ReadCommand(0x22) >> 2) & 0x3) + 1) * 8;
WiredHome 19:3f82c1161fd2 454 else
WiredHome 29:422616aa04bd 455 return font[1];
WiredHome 19:3f82c1161fd2 456 }
WiredHome 19:3f82c1161fd2 457
WiredHome 44:207594dece70 458
WiredHome 37:f19b7e7449dc 459 dim_t RA8875::fontheight(void)
WiredHome 19:3f82c1161fd2 460 {
WiredHome 19:3f82c1161fd2 461 if (font == NULL)
WiredHome 23:a50ded45dbaf 462 return (((ReadCommand(0x22) >> 0) & 0x3) + 1) * 16;
WiredHome 19:3f82c1161fd2 463 else
WiredHome 29:422616aa04bd 464 return font[2];
WiredHome 19:3f82c1161fd2 465 }
WiredHome 19:3f82c1161fd2 466
WiredHome 44:207594dece70 467
WiredHome 37:f19b7e7449dc 468 RetCode_t RA8875::locate(textloc_t column, textloc_t row)
WiredHome 19:3f82c1161fd2 469 {
WiredHome 32:0e4f2ae512e2 470 return SetTextCursor(column * fontwidth(), row * fontheight());
WiredHome 19:3f82c1161fd2 471 }
WiredHome 19:3f82c1161fd2 472
WiredHome 44:207594dece70 473
WiredHome 19:3f82c1161fd2 474 int RA8875::columns(void)
WiredHome 19:3f82c1161fd2 475 {
WiredHome 19:3f82c1161fd2 476 return width() / fontwidth();
WiredHome 19:3f82c1161fd2 477 }
WiredHome 19:3f82c1161fd2 478
WiredHome 44:207594dece70 479
WiredHome 19:3f82c1161fd2 480 int RA8875::rows(void)
WiredHome 19:3f82c1161fd2 481 {
WiredHome 19:3f82c1161fd2 482 return height() / fontheight();
WiredHome 19:3f82c1161fd2 483 }
WiredHome 19:3f82c1161fd2 484
WiredHome 44:207594dece70 485
WiredHome 38:38d503b4fad6 486 dim_t RA8875::width(void)
WiredHome 19:3f82c1161fd2 487 {
WiredHome 29:422616aa04bd 488 return (ReadCommand(0x14) + 1) * 8;
WiredHome 19:3f82c1161fd2 489 }
WiredHome 19:3f82c1161fd2 490
WiredHome 44:207594dece70 491
WiredHome 38:38d503b4fad6 492 dim_t RA8875::height(void)
WiredHome 19:3f82c1161fd2 493 {
WiredHome 29:422616aa04bd 494 return (ReadCommand(0x19) | (ReadCommand(0x1A) << 8)) + 1;
WiredHome 19:3f82c1161fd2 495 }
WiredHome 19:3f82c1161fd2 496
WiredHome 44:207594dece70 497
WiredHome 43:3becae133285 498 dim_t RA8875::color_bpp(void)
WiredHome 43:3becae133285 499 {
WiredHome 43:3becae133285 500 if ((ReadCommand(0x10) & 0x0C) == 0x04)
WiredHome 43:3becae133285 501 return 16;
WiredHome 43:3becae133285 502 else
WiredHome 43:3becae133285 503 return 8;
WiredHome 43:3becae133285 504 }
WiredHome 43:3becae133285 505
WiredHome 44:207594dece70 506
WiredHome 37:f19b7e7449dc 507 RetCode_t RA8875::SetTextCursor(loc_t x, loc_t y)
WiredHome 19:3f82c1161fd2 508 {
WiredHome 29:422616aa04bd 509 cursor_x = x; cursor_y = y; // for non-internal fonts
WiredHome 38:38d503b4fad6 510 WriteCommandW(0x2A, x);
WiredHome 38:38d503b4fad6 511 WriteCommandW(0x2C, y);
WiredHome 19:3f82c1161fd2 512 return noerror;
WiredHome 19:3f82c1161fd2 513 }
WiredHome 19:3f82c1161fd2 514
WiredHome 44:207594dece70 515
WiredHome 37:f19b7e7449dc 516 loc_t RA8875::GetTextCursor_Y(void)
WiredHome 29:422616aa04bd 517 {
WiredHome 29:422616aa04bd 518 if (font == NULL)
WiredHome 29:422616aa04bd 519 return ReadCommand(0x2C) | (ReadCommand(0x2D) << 8);
WiredHome 29:422616aa04bd 520 else
WiredHome 29:422616aa04bd 521 return cursor_y;
WiredHome 29:422616aa04bd 522 }
WiredHome 29:422616aa04bd 523
WiredHome 44:207594dece70 524
WiredHome 37:f19b7e7449dc 525 loc_t RA8875::GetTextCursor_X(void)
WiredHome 29:422616aa04bd 526 {
WiredHome 29:422616aa04bd 527 if (font == NULL)
WiredHome 29:422616aa04bd 528 return ReadCommand(0x2A) | (ReadCommand(0x2B) << 8);
WiredHome 29:422616aa04bd 529 else
WiredHome 29:422616aa04bd 530 return cursor_x;
WiredHome 29:422616aa04bd 531 }
WiredHome 29:422616aa04bd 532
WiredHome 44:207594dece70 533
WiredHome 24:8ca861acf12d 534 RetCode_t RA8875::SetTextCursorControl(cursor_t cursor, bool blink)
WiredHome 23:a50ded45dbaf 535 {
WiredHome 23:a50ded45dbaf 536 unsigned char mwcr0 = ReadCommand(0x40) & 0x0F; // retain direction, auto-increase
WiredHome 43:3becae133285 537 unsigned char mwcr1 = ReadCommand(0x41) & 0x01; // retain currently selected layer
WiredHome 24:8ca861acf12d 538 unsigned char horz = 0;
WiredHome 24:8ca861acf12d 539 unsigned char vert = 0;
WiredHome 23:a50ded45dbaf 540
WiredHome 24:8ca861acf12d 541 mwcr0 |= 0x80; // text mode
WiredHome 24:8ca861acf12d 542 if (cursor != NOCURSOR)
WiredHome 24:8ca861acf12d 543 mwcr0 |= 0x40; // visible
WiredHome 23:a50ded45dbaf 544 if (blink)
WiredHome 24:8ca861acf12d 545 mwcr0 |= 0x20; // blink
WiredHome 23:a50ded45dbaf 546 WriteCommand(0x40, mwcr0); // configure the cursor
WiredHome 43:3becae133285 547 WriteCommand(0x41, mwcr1); // close the graphics cursor
WiredHome 24:8ca861acf12d 548 WriteCommand(0x44, 0x1f); // The cursor flashing cycle
WiredHome 24:8ca861acf12d 549 switch (cursor) {
WiredHome 24:8ca861acf12d 550 case IBEAM:
WiredHome 24:8ca861acf12d 551 horz = 0x01;
WiredHome 24:8ca861acf12d 552 vert = 0x1F;
WiredHome 24:8ca861acf12d 553 break;
WiredHome 24:8ca861acf12d 554 case UNDER:
WiredHome 24:8ca861acf12d 555 horz = 0x07;
WiredHome 24:8ca861acf12d 556 vert = 0x01;
WiredHome 24:8ca861acf12d 557 break;
WiredHome 24:8ca861acf12d 558 case BLOCK:
WiredHome 24:8ca861acf12d 559 horz = 0x07;
WiredHome 24:8ca861acf12d 560 vert = 0x1F;
WiredHome 24:8ca861acf12d 561 break;
WiredHome 24:8ca861acf12d 562 case NOCURSOR:
WiredHome 24:8ca861acf12d 563 default:
WiredHome 24:8ca861acf12d 564 break;
WiredHome 24:8ca861acf12d 565 }
WiredHome 24:8ca861acf12d 566 WriteCommand(0x4e, horz); // The cursor size horz
WiredHome 24:8ca861acf12d 567 WriteCommand(0x4f, vert); // The cursor size vert
WiredHome 23:a50ded45dbaf 568 return noerror;
WiredHome 23:a50ded45dbaf 569 }
WiredHome 23:a50ded45dbaf 570
WiredHome 44:207594dece70 571
WiredHome 19:3f82c1161fd2 572 RetCode_t RA8875::SetTextFont(RA8875::font_t font)
WiredHome 19:3f82c1161fd2 573 {
WiredHome 19:3f82c1161fd2 574 if (/*font >= RA8875::ISO8859_1 && */ font <= RA8875::ISO8859_4) {
WiredHome 19:3f82c1161fd2 575 WriteCommand(0x21, (unsigned int)(font));
WiredHome 19:3f82c1161fd2 576 return noerror;
WiredHome 19:3f82c1161fd2 577 } else {
WiredHome 19:3f82c1161fd2 578 return bad_parameter;
WiredHome 19:3f82c1161fd2 579 }
WiredHome 19:3f82c1161fd2 580 }
WiredHome 19:3f82c1161fd2 581
WiredHome 44:207594dece70 582
WiredHome 19:3f82c1161fd2 583 RetCode_t RA8875::SetTextFontControl(fill_t fillit,
WiredHome 19:3f82c1161fd2 584 RA8875::font_angle_t angle,
WiredHome 19:3f82c1161fd2 585 RA8875::HorizontalScale hScale,
WiredHome 19:3f82c1161fd2 586 RA8875::VerticalScale vScale,
WiredHome 19:3f82c1161fd2 587 RA8875::alignment_t alignment)
WiredHome 19:3f82c1161fd2 588 {
WiredHome 19:3f82c1161fd2 589 if (hScale >= 1 && hScale <= 4 &&
WiredHome 19:3f82c1161fd2 590 vScale >= 1 && vScale <= 4) {
WiredHome 19:3f82c1161fd2 591 unsigned char x = 0;
WiredHome 19:3f82c1161fd2 592
WiredHome 19:3f82c1161fd2 593 if (alignment == align_full)
WiredHome 19:3f82c1161fd2 594 x |= 0x80;
WiredHome 19:3f82c1161fd2 595 if (fillit == NOFILL)
WiredHome 19:3f82c1161fd2 596 x |= 0x40;
WiredHome 19:3f82c1161fd2 597 if (angle == rotated)
WiredHome 19:3f82c1161fd2 598 x |= 0x10;
WiredHome 19:3f82c1161fd2 599 x |= ((hScale - 1) << 2);
WiredHome 19:3f82c1161fd2 600 x |= ((vScale - 1) << 0);
WiredHome 19:3f82c1161fd2 601 WriteCommand(0x22, x);
WiredHome 19:3f82c1161fd2 602 return noerror;
WiredHome 19:3f82c1161fd2 603 } else {
WiredHome 19:3f82c1161fd2 604 return bad_parameter;
WiredHome 19:3f82c1161fd2 605 }
WiredHome 19:3f82c1161fd2 606 }
WiredHome 19:3f82c1161fd2 607
WiredHome 44:207594dece70 608
WiredHome 19:3f82c1161fd2 609 RetCode_t RA8875::SetTextFontSize(RA8875::HorizontalScale hScale, RA8875::VerticalScale vScale)
WiredHome 19:3f82c1161fd2 610 {
WiredHome 19:3f82c1161fd2 611 unsigned char reg = ReadCommand(0x22);
WiredHome 19:3f82c1161fd2 612
WiredHome 40:04aa280dfa39 613 if (vScale == -1)
WiredHome 40:04aa280dfa39 614 vScale = hScale;
WiredHome 19:3f82c1161fd2 615 if (hScale >= 1 && hScale <= 4 && vScale >= 1 && vScale <= 4) {
WiredHome 19:3f82c1161fd2 616 reg &= 0xF0; // keep the high nibble as is.
WiredHome 19:3f82c1161fd2 617 reg |= ((hScale - 1) << 2);
WiredHome 19:3f82c1161fd2 618 reg |= ((vScale - 1) << 0);
WiredHome 19:3f82c1161fd2 619 WriteCommand(0x22, reg);
WiredHome 19:3f82c1161fd2 620 return noerror;
WiredHome 19:3f82c1161fd2 621 } else {
WiredHome 19:3f82c1161fd2 622 return bad_parameter;
WiredHome 19:3f82c1161fd2 623 }
WiredHome 19:3f82c1161fd2 624 }
WiredHome 19:3f82c1161fd2 625
WiredHome 44:207594dece70 626
WiredHome 19:3f82c1161fd2 627 int RA8875::_putc(int c)
WiredHome 19:3f82c1161fd2 628 {
WiredHome 29:422616aa04bd 629 if (font == NULL) {
WiredHome 29:422616aa04bd 630 return _internal_putc(c);
WiredHome 29:422616aa04bd 631 } else {
WiredHome 29:422616aa04bd 632 return _external_putc(c);
WiredHome 29:422616aa04bd 633 }
WiredHome 29:422616aa04bd 634 }
WiredHome 29:422616aa04bd 635
WiredHome 44:207594dece70 636
WiredHome 29:422616aa04bd 637 int RA8875::_external_putc(int c)
WiredHome 29:422616aa04bd 638 {
WiredHome 19:3f82c1161fd2 639 if (c) {
WiredHome 19:3f82c1161fd2 640 if (c == '\r') {
WiredHome 29:422616aa04bd 641 cursor_x = 0;
WiredHome 29:422616aa04bd 642 } else if (c == '\n') {
WiredHome 29:422616aa04bd 643 cursor_y += font[2];
WiredHome 29:422616aa04bd 644 } else {
WiredHome 29:422616aa04bd 645 int advance = character(cursor_x, cursor_y, c); // advance tells us how many pixels we advanced
WiredHome 37:f19b7e7449dc 646 //INFO("x,y,advance %d,%d,%d", cursor_x, cursor_y, advance);
WiredHome 29:422616aa04bd 647 if (advance) {
WiredHome 29:422616aa04bd 648 cursor_x += advance;
WiredHome 29:422616aa04bd 649 if (cursor_x >= width()) {
WiredHome 29:422616aa04bd 650 cursor_x = 0;
WiredHome 29:422616aa04bd 651 cursor_y += font[2];
WiredHome 29:422616aa04bd 652 if (cursor_y >= height()) {
WiredHome 29:422616aa04bd 653 cursor_y = 0; // @todo Should it scroll?
WiredHome 29:422616aa04bd 654 }
WiredHome 29:422616aa04bd 655 }
WiredHome 29:422616aa04bd 656 }
WiredHome 29:422616aa04bd 657 }
WiredHome 29:422616aa04bd 658 }
WiredHome 29:422616aa04bd 659 return c;
WiredHome 29:422616aa04bd 660 }
WiredHome 29:422616aa04bd 661
WiredHome 44:207594dece70 662
WiredHome 29:422616aa04bd 663 int RA8875::_internal_putc(int c)
WiredHome 29:422616aa04bd 664 {
WiredHome 29:422616aa04bd 665 if (c) {
WiredHome 29:422616aa04bd 666 unsigned char mwcr0;
WiredHome 29:422616aa04bd 667
WiredHome 29:422616aa04bd 668 mwcr0 = ReadCommand(0x40);
WiredHome 29:422616aa04bd 669 if ((mwcr0 & 0x80) == 0x00) {
WiredHome 29:422616aa04bd 670 WriteCommand(0x40, 0x80 | mwcr0); // Put in Text mode if not already
WiredHome 29:422616aa04bd 671 }
WiredHome 29:422616aa04bd 672 if (c == '\r') {
WiredHome 37:f19b7e7449dc 673 loc_t x;
WiredHome 19:3f82c1161fd2 674 x = ReadCommand(0x30) | (ReadCommand(0x31) << 8); // Left edge of active window
WiredHome 38:38d503b4fad6 675 WriteCommandW(0x2A, x);
WiredHome 19:3f82c1161fd2 676 } else if (c == '\n') {
WiredHome 37:f19b7e7449dc 677 loc_t y;
WiredHome 19:3f82c1161fd2 678 y = ReadCommand(0x2C) | (ReadCommand(0x2D) << 8); // current y location
WiredHome 19:3f82c1161fd2 679 y += fontheight();
WiredHome 47:d96a09269f91 680 if (y >= height()) // @TODO after bottom of active window, then scroll window?
WiredHome 19:3f82c1161fd2 681 y = 0;
WiredHome 38:38d503b4fad6 682 WriteCommandW(0x2C, y);
WiredHome 19:3f82c1161fd2 683 } else {
WiredHome 29:422616aa04bd 684 WriteCommand(0x02); // RA8875 Internal Fonts
WiredHome 29:422616aa04bd 685 select(true);
WiredHome 29:422616aa04bd 686 WriteData(c);
WiredHome 66:468a11f05580 687 _WaitWhileBusy(0x80);
WiredHome 29:422616aa04bd 688 select(false);
WiredHome 19:3f82c1161fd2 689 }
WiredHome 19:3f82c1161fd2 690 }
WiredHome 19:3f82c1161fd2 691 return c;
WiredHome 19:3f82c1161fd2 692 }
WiredHome 19:3f82c1161fd2 693
WiredHome 44:207594dece70 694
WiredHome 32:0e4f2ae512e2 695 RetCode_t RA8875::_StartGraphicsStream(void)
WiredHome 32:0e4f2ae512e2 696 {
WiredHome 32:0e4f2ae512e2 697 WriteCommand(0x40,0x00); // Graphics write mode
WiredHome 32:0e4f2ae512e2 698 WriteCommand(0x02); // Prepare for streaming data
WiredHome 32:0e4f2ae512e2 699 return noerror;
WiredHome 32:0e4f2ae512e2 700 }
WiredHome 32:0e4f2ae512e2 701
WiredHome 44:207594dece70 702
WiredHome 32:0e4f2ae512e2 703 RetCode_t RA8875::_EndGraphicsStream(void)
WiredHome 32:0e4f2ae512e2 704 {
WiredHome 32:0e4f2ae512e2 705 return noerror;
WiredHome 32:0e4f2ae512e2 706 }
WiredHome 32:0e4f2ae512e2 707
WiredHome 44:207594dece70 708
WiredHome 55:dfbabef7003e 709 RetCode_t RA8875::_putp(color_t pixel)
WiredHome 32:0e4f2ae512e2 710 {
WiredHome 38:38d503b4fad6 711 WriteDataW((pixel>>8) | (pixel<<8));
WiredHome 32:0e4f2ae512e2 712 return noerror;
WiredHome 32:0e4f2ae512e2 713 }
WiredHome 29:422616aa04bd 714
WiredHome 44:207594dece70 715
WiredHome 37:f19b7e7449dc 716 void RA8875::puts(loc_t x, loc_t y, const char * string)
WiredHome 19:3f82c1161fd2 717 {
WiredHome 19:3f82c1161fd2 718 SetTextCursor(x,y);
WiredHome 19:3f82c1161fd2 719 puts(string);
WiredHome 19:3f82c1161fd2 720 }
WiredHome 19:3f82c1161fd2 721
WiredHome 44:207594dece70 722
WiredHome 19:3f82c1161fd2 723 void RA8875::puts(const char * string)
WiredHome 19:3f82c1161fd2 724 {
WiredHome 29:422616aa04bd 725 unsigned char mwcr0 = ReadCommand(0x40);
WiredHome 37:f19b7e7449dc 726
WiredHome 37:f19b7e7449dc 727 if (font == NULL) {
WiredHome 37:f19b7e7449dc 728 if ((mwcr0 & 0x80) == 0x00)
WiredHome 37:f19b7e7449dc 729 WriteCommand(0x40,0x80); // Put in Text mode if not already
WiredHome 37:f19b7e7449dc 730 } else {
WiredHome 37:f19b7e7449dc 731 _StartGraphicsStream();
WiredHome 37:f19b7e7449dc 732 }
WiredHome 19:3f82c1161fd2 733 if (*string != '\0') {
WiredHome 19:3f82c1161fd2 734 #if 1
WiredHome 29:422616aa04bd 735 while (*string) { // @TODO calling individual _putc is slower... optimizations?
WiredHome 19:3f82c1161fd2 736 _putc(*string++);
WiredHome 19:3f82c1161fd2 737 }
WiredHome 19:3f82c1161fd2 738 #else
WiredHome 19:3f82c1161fd2 739 WriteCommand(0x02);
WiredHome 19:3f82c1161fd2 740 select(true);
WiredHome 19:3f82c1161fd2 741 while (*string != '\0') {
WiredHome 19:3f82c1161fd2 742 WriteData(*string);
WiredHome 19:3f82c1161fd2 743 ++string;
WiredHome 66:468a11f05580 744 _WaitWhileBusy(0x80);
WiredHome 19:3f82c1161fd2 745 }
WiredHome 19:3f82c1161fd2 746 select(false);
WiredHome 19:3f82c1161fd2 747 #endif
WiredHome 19:3f82c1161fd2 748 }
WiredHome 37:f19b7e7449dc 749 if (font)
WiredHome 37:f19b7e7449dc 750 _EndGraphicsStream();
WiredHome 19:3f82c1161fd2 751 }
WiredHome 19:3f82c1161fd2 752
WiredHome 44:207594dece70 753
WiredHome 37:f19b7e7449dc 754 RetCode_t RA8875::SetGraphicsCursor(loc_t x, loc_t y)
WiredHome 19:3f82c1161fd2 755 {
WiredHome 38:38d503b4fad6 756 WriteCommandW(0x46, x);
WiredHome 38:38d503b4fad6 757 WriteCommandW(0x48, y);
WiredHome 19:3f82c1161fd2 758 return noerror;
WiredHome 19:3f82c1161fd2 759 }
WiredHome 19:3f82c1161fd2 760
WiredHome 44:207594dece70 761
WiredHome 41:2956a0a221e5 762 RetCode_t RA8875::SetGraphicsCursorRead(loc_t x, loc_t y)
WiredHome 41:2956a0a221e5 763 {
WiredHome 41:2956a0a221e5 764 //WriteCommand(0x40, 0); // Graphics mode
WiredHome 41:2956a0a221e5 765 //WriteCommand(0x45, 0); // left->right, top->bottom
WiredHome 41:2956a0a221e5 766 WriteCommandW(0x4A, x);
WiredHome 41:2956a0a221e5 767 WriteCommandW(0x4C, y);
WiredHome 41:2956a0a221e5 768 return noerror;
WiredHome 41:2956a0a221e5 769 }
WiredHome 41:2956a0a221e5 770
WiredHome 44:207594dece70 771
WiredHome 37:f19b7e7449dc 772 RetCode_t RA8875::window(loc_t x, loc_t y, dim_t width, dim_t height)
WiredHome 19:3f82c1161fd2 773 {
WiredHome 37:f19b7e7449dc 774 GraphicsDisplay::window(x,y, width,height);
WiredHome 38:38d503b4fad6 775 WriteCommandW(0x30, x);
WiredHome 38:38d503b4fad6 776 WriteCommandW(0x32, y);
WiredHome 38:38d503b4fad6 777 WriteCommandW(0x34, (x+width-1));
WiredHome 38:38d503b4fad6 778 WriteCommandW(0x36, (y+height-1));
WiredHome 37:f19b7e7449dc 779 SetGraphicsCursor(x,y);
WiredHome 19:3f82c1161fd2 780 return noerror;
WiredHome 19:3f82c1161fd2 781 }
WiredHome 19:3f82c1161fd2 782
WiredHome 44:207594dece70 783
WiredHome 61:8f3153bf0baa 784 RetCode_t RA8875::cls(uint16_t layers)
WiredHome 19:3f82c1161fd2 785 {
WiredHome 61:8f3153bf0baa 786 RetCode_t ret;
WiredHome 61:8f3153bf0baa 787
WiredHome 19:3f82c1161fd2 788 PERFORMANCE_RESET;
WiredHome 61:8f3153bf0baa 789 if (layers == 0) {
WiredHome 61:8f3153bf0baa 790 ret = clsw(FULLWINDOW);
WiredHome 61:8f3153bf0baa 791 ret = SetTextCursor(0,0);
WiredHome 61:8f3153bf0baa 792 } else if (layers > 3) {
WiredHome 61:8f3153bf0baa 793 ret = bad_parameter;
WiredHome 61:8f3153bf0baa 794 } else {
WiredHome 61:8f3153bf0baa 795 uint16_t prevLayer = GetDrawingLayer();
WiredHome 61:8f3153bf0baa 796 if (layers & 1) {
WiredHome 61:8f3153bf0baa 797 SelectDrawingLayer(0);
WiredHome 61:8f3153bf0baa 798 clsw(FULLWINDOW);
WiredHome 61:8f3153bf0baa 799 }
WiredHome 61:8f3153bf0baa 800 if (layers & 2) {
WiredHome 61:8f3153bf0baa 801 SelectDrawingLayer(1);
WiredHome 61:8f3153bf0baa 802 clsw(FULLWINDOW);
WiredHome 61:8f3153bf0baa 803 }
WiredHome 61:8f3153bf0baa 804 ret = SelectDrawingLayer(prevLayer);
WiredHome 61:8f3153bf0baa 805 }
WiredHome 19:3f82c1161fd2 806 REGISTERPERFORMANCE(PRF_CLS);
WiredHome 61:8f3153bf0baa 807 return ret;
WiredHome 19:3f82c1161fd2 808 }
WiredHome 19:3f82c1161fd2 809
WiredHome 44:207594dece70 810
WiredHome 19:3f82c1161fd2 811 RetCode_t RA8875::clsw(RA8875::Region_t region)
WiredHome 19:3f82c1161fd2 812 {
WiredHome 19:3f82c1161fd2 813 PERFORMANCE_RESET;
WiredHome 19:3f82c1161fd2 814 WriteCommand(0x8E, (region == ACTIVEWINDOW) ? 0xC0 : 0x80);
WiredHome 66:468a11f05580 815 _WaitWhileReg(0x8E, 0x80);
WiredHome 19:3f82c1161fd2 816 REGISTERPERFORMANCE(PRF_CLS);
WiredHome 19:3f82c1161fd2 817 return noerror;
WiredHome 19:3f82c1161fd2 818 }
WiredHome 19:3f82c1161fd2 819
WiredHome 44:207594dece70 820
WiredHome 37:f19b7e7449dc 821 RetCode_t RA8875::pixel(loc_t x, loc_t y, color_t color)
WiredHome 19:3f82c1161fd2 822 {
WiredHome 62:ba5d33438fda 823 RetCode_t ret;
WiredHome 62:ba5d33438fda 824
WiredHome 62:ba5d33438fda 825 PERFORMANCE_RESET;
WiredHome 41:2956a0a221e5 826 #if 1
WiredHome 62:ba5d33438fda 827 ret = pixelStream(&color, 1, x,y);
WiredHome 41:2956a0a221e5 828 #else
WiredHome 19:3f82c1161fd2 829 foreground(color);
WiredHome 62:ba5d33438fda 830 ret = pixel(x,y);
WiredHome 41:2956a0a221e5 831 #endif
WiredHome 62:ba5d33438fda 832 REGISTERPERFORMANCE(PRF_DRAWPIXEL);
WiredHome 62:ba5d33438fda 833 return ret;
WiredHome 19:3f82c1161fd2 834 }
WiredHome 19:3f82c1161fd2 835
WiredHome 44:207594dece70 836
WiredHome 37:f19b7e7449dc 837 RetCode_t RA8875::pixel(loc_t x, loc_t y)
WiredHome 19:3f82c1161fd2 838 {
WiredHome 19:3f82c1161fd2 839 RetCode_t ret;
WiredHome 19:3f82c1161fd2 840
WiredHome 19:3f82c1161fd2 841 PERFORMANCE_RESET;
WiredHome 19:3f82c1161fd2 842 color_t color = GetForeColor();
WiredHome 62:ba5d33438fda 843 #if 1
WiredHome 62:ba5d33438fda 844 ret = pixelStream(&color, 1, x, y);
WiredHome 62:ba5d33438fda 845 #else
WiredHome 19:3f82c1161fd2 846 WriteCommand(0x40,0x00); // Graphics write mode
WiredHome 32:0e4f2ae512e2 847 SetGraphicsCursor(x, y);
WiredHome 38:38d503b4fad6 848 WriteCommand(0x02);
WiredHome 38:38d503b4fad6 849 WriteDataW(color);
WiredHome 19:3f82c1161fd2 850 ret = noerror;
WiredHome 62:ba5d33438fda 851 #endif
WiredHome 41:2956a0a221e5 852 REGISTERPERFORMANCE(PRF_DRAWPIXEL);
WiredHome 19:3f82c1161fd2 853 return ret;
WiredHome 19:3f82c1161fd2 854 }
WiredHome 19:3f82c1161fd2 855
WiredHome 44:207594dece70 856
WiredHome 41:2956a0a221e5 857 RetCode_t RA8875::pixelStream(color_t * p, uint32_t count, loc_t x, loc_t y)
WiredHome 41:2956a0a221e5 858 {
WiredHome 41:2956a0a221e5 859 PERFORMANCE_RESET;
WiredHome 41:2956a0a221e5 860 WriteCommand(0x40,0x00); // Graphics write mode
WiredHome 41:2956a0a221e5 861 SetGraphicsCursor(x, y);
WiredHome 41:2956a0a221e5 862 WriteCommand(0x02);
WiredHome 41:2956a0a221e5 863 select(true);
WiredHome 41:2956a0a221e5 864 spiwrite(0x00); // Cmd: write data
WiredHome 41:2956a0a221e5 865 while (count--) {
WiredHome 41:2956a0a221e5 866 spiwrite(*p >> 8);
WiredHome 41:2956a0a221e5 867 spiwrite(*p & 0xFF);
WiredHome 41:2956a0a221e5 868 p++;
WiredHome 41:2956a0a221e5 869 }
WiredHome 41:2956a0a221e5 870 select(false);
WiredHome 41:2956a0a221e5 871 REGISTERPERFORMANCE(PRF_PIXELSTREAM);
WiredHome 41:2956a0a221e5 872 return(noerror);
WiredHome 41:2956a0a221e5 873 }
WiredHome 41:2956a0a221e5 874
WiredHome 44:207594dece70 875
WiredHome 41:2956a0a221e5 876 color_t RA8875::getPixel(loc_t x, loc_t y)
WiredHome 41:2956a0a221e5 877 {
WiredHome 41:2956a0a221e5 878 color_t pixel;
WiredHome 41:2956a0a221e5 879
WiredHome 41:2956a0a221e5 880 PERFORMANCE_RESET;
WiredHome 41:2956a0a221e5 881 //WriteCommand(0x45,0x00); // read left->right, top->bottom
WiredHome 41:2956a0a221e5 882 WriteCommand(0x40,0x00); // Graphics write mode
WiredHome 41:2956a0a221e5 883 SetGraphicsCursorRead(x, y);
WiredHome 41:2956a0a221e5 884 WriteCommand(0x02);
WiredHome 41:2956a0a221e5 885 select(true);
WiredHome 41:2956a0a221e5 886 spiwrite(0x40); // Cmd: read data
WiredHome 41:2956a0a221e5 887 spiwrite(0x00); // dummy read
WiredHome 41:2956a0a221e5 888 pixel = spiread();
WiredHome 41:2956a0a221e5 889 pixel |= (spiread() << 8);
WiredHome 41:2956a0a221e5 890 select(false);
WiredHome 41:2956a0a221e5 891 REGISTERPERFORMANCE(PRF_READPIXEL);
WiredHome 41:2956a0a221e5 892 return pixel;
WiredHome 41:2956a0a221e5 893 }
WiredHome 41:2956a0a221e5 894
WiredHome 44:207594dece70 895
WiredHome 41:2956a0a221e5 896 RetCode_t RA8875::getPixelStream(color_t * p, uint32_t count, loc_t x, loc_t y)
WiredHome 41:2956a0a221e5 897 {
WiredHome 41:2956a0a221e5 898 color_t pixel;
WiredHome 41:2956a0a221e5 899
WiredHome 41:2956a0a221e5 900 PERFORMANCE_RESET;
WiredHome 41:2956a0a221e5 901 //WriteCommand(0x45,0x00); // read left->right, top->bottom
WiredHome 41:2956a0a221e5 902 WriteCommand(0x40,0x00); // Graphics write mode
WiredHome 41:2956a0a221e5 903 SetGraphicsCursorRead(x, y);
WiredHome 41:2956a0a221e5 904 WriteCommand(0x02);
WiredHome 41:2956a0a221e5 905 select(true);
WiredHome 41:2956a0a221e5 906 spiwrite(0x40); // Cmd: read data
WiredHome 41:2956a0a221e5 907 spiwrite(0x00); // dummy read
WiredHome 41:2956a0a221e5 908 while (count--) {
WiredHome 41:2956a0a221e5 909 pixel = spiread();
WiredHome 41:2956a0a221e5 910 pixel |= (spiread() << 8);
WiredHome 41:2956a0a221e5 911 *p++ = pixel;
WiredHome 41:2956a0a221e5 912 }
WiredHome 41:2956a0a221e5 913 select(false);
WiredHome 41:2956a0a221e5 914 REGISTERPERFORMANCE(PRF_READPIXELSTREAM);
WiredHome 41:2956a0a221e5 915 return noerror;
WiredHome 41:2956a0a221e5 916 }
WiredHome 41:2956a0a221e5 917
WiredHome 44:207594dece70 918
WiredHome 37:f19b7e7449dc 919 RetCode_t RA8875::line(loc_t x1, loc_t y1, loc_t x2, loc_t y2, color_t color)
WiredHome 19:3f82c1161fd2 920 {
WiredHome 19:3f82c1161fd2 921 foreground(color);
WiredHome 19:3f82c1161fd2 922 return line(x1,y1,x2,y2);
WiredHome 19:3f82c1161fd2 923 }
WiredHome 19:3f82c1161fd2 924
WiredHome 44:207594dece70 925
WiredHome 37:f19b7e7449dc 926 RetCode_t RA8875::line(loc_t x1, loc_t y1, loc_t x2, loc_t y2)
WiredHome 19:3f82c1161fd2 927 {
WiredHome 19:3f82c1161fd2 928 PERFORMANCE_RESET;
WiredHome 62:ba5d33438fda 929 if (x1 == x2 && y1 == y2) {
WiredHome 60:2dfd574f63bd 930 pixel(x1, y1);
WiredHome 62:ba5d33438fda 931 } else {
WiredHome 60:2dfd574f63bd 932 WriteCommandW(0x91, x1);
WiredHome 60:2dfd574f63bd 933 WriteCommandW(0x93, y1);
WiredHome 60:2dfd574f63bd 934 WriteCommandW(0x95, x2);
WiredHome 60:2dfd574f63bd 935 WriteCommandW(0x97, y2);
WiredHome 60:2dfd574f63bd 936 unsigned char drawCmd = 0x00; // Line
WiredHome 60:2dfd574f63bd 937 WriteCommand(0x90, drawCmd);
WiredHome 60:2dfd574f63bd 938 WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
WiredHome 66:468a11f05580 939 _WaitWhileReg(0x90, 0x80);
WiredHome 60:2dfd574f63bd 940 }
WiredHome 19:3f82c1161fd2 941 REGISTERPERFORMANCE(PRF_DRAWLINE);
WiredHome 19:3f82c1161fd2 942 return noerror;
WiredHome 19:3f82c1161fd2 943 }
WiredHome 19:3f82c1161fd2 944
WiredHome 44:207594dece70 945
WiredHome 37:f19b7e7449dc 946 RetCode_t RA8875::fillrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 19:3f82c1161fd2 947 color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 948 {
WiredHome 19:3f82c1161fd2 949 return rect(x1,y1,x2,y2,color,fillit);
WiredHome 19:3f82c1161fd2 950 }
WiredHome 19:3f82c1161fd2 951
WiredHome 44:207594dece70 952
WiredHome 37:f19b7e7449dc 953 RetCode_t RA8875::rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 19:3f82c1161fd2 954 color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 955 {
WiredHome 19:3f82c1161fd2 956 foreground(color);
WiredHome 19:3f82c1161fd2 957 return rect(x1,y1,x2,y2,fillit);
WiredHome 19:3f82c1161fd2 958 }
WiredHome 19:3f82c1161fd2 959
WiredHome 44:207594dece70 960
WiredHome 37:f19b7e7449dc 961 RetCode_t RA8875::rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 19:3f82c1161fd2 962 fill_t fillit)
WiredHome 19:3f82c1161fd2 963 {
WiredHome 19:3f82c1161fd2 964 PERFORMANCE_RESET;
WiredHome 19:3f82c1161fd2 965 if (x1 == x2 && y1 == y2) {
WiredHome 19:3f82c1161fd2 966 pixel(x1, y1);
WiredHome 19:3f82c1161fd2 967 } else if (x1 == x2) {
WiredHome 19:3f82c1161fd2 968 line(x1, y1, x2, y2);
WiredHome 19:3f82c1161fd2 969 } else if (y1 == y2) {
WiredHome 19:3f82c1161fd2 970 line(x1, y1, x2, y2);
WiredHome 19:3f82c1161fd2 971 } else {
WiredHome 38:38d503b4fad6 972 WriteCommandW(0x91, x1);
WiredHome 38:38d503b4fad6 973 WriteCommandW(0x93, y1);
WiredHome 38:38d503b4fad6 974 WriteCommandW(0x95, x2);
WiredHome 38:38d503b4fad6 975 WriteCommandW(0x97, y2);
WiredHome 19:3f82c1161fd2 976 unsigned char drawCmd = 0x10; // Rectangle
WiredHome 19:3f82c1161fd2 977 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 978 drawCmd |= 0x20;
WiredHome 19:3f82c1161fd2 979 WriteCommand(0x90, drawCmd);
WiredHome 19:3f82c1161fd2 980 WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
WiredHome 66:468a11f05580 981 _WaitWhileReg(0x90, 0x80);
WiredHome 19:3f82c1161fd2 982 }
WiredHome 19:3f82c1161fd2 983 REGISTERPERFORMANCE(PRF_DRAWRECTANGLE);
WiredHome 19:3f82c1161fd2 984 return noerror;
WiredHome 19:3f82c1161fd2 985 }
WiredHome 19:3f82c1161fd2 986
WiredHome 44:207594dece70 987
WiredHome 37:f19b7e7449dc 988 RetCode_t RA8875::fillroundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 37:f19b7e7449dc 989 dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 990 {
WiredHome 19:3f82c1161fd2 991 foreground(color);
WiredHome 19:3f82c1161fd2 992 return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
WiredHome 19:3f82c1161fd2 993 }
WiredHome 19:3f82c1161fd2 994
WiredHome 44:207594dece70 995
WiredHome 37:f19b7e7449dc 996 RetCode_t RA8875::roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 37:f19b7e7449dc 997 dim_t radius1, dim_t radius2, color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 998 {
WiredHome 19:3f82c1161fd2 999 foreground(color);
WiredHome 19:3f82c1161fd2 1000 return roundrect(x1,y1,x2,y2,radius1,radius2,fillit);
WiredHome 19:3f82c1161fd2 1001 }
WiredHome 19:3f82c1161fd2 1002
WiredHome 44:207594dece70 1003
WiredHome 37:f19b7e7449dc 1004 RetCode_t RA8875::roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 37:f19b7e7449dc 1005 dim_t radius1, dim_t radius2, fill_t fillit)
WiredHome 19:3f82c1161fd2 1006 {
WiredHome 19:3f82c1161fd2 1007 RetCode_t ret = noerror;
WiredHome 19:3f82c1161fd2 1008
WiredHome 19:3f82c1161fd2 1009 PERFORMANCE_RESET;
WiredHome 21:3c1efb192927 1010 if (x1 > x2 || y1 > y2 || (radius1 > (x2-x1)/2) || (radius2 > (y2-y1)/2) ) {
WiredHome 21:3c1efb192927 1011 ret = bad_parameter;
WiredHome 21:3c1efb192927 1012 } else if (x1 == x2 && y1 == y2) {
WiredHome 19:3f82c1161fd2 1013 pixel(x1, y1);
WiredHome 19:3f82c1161fd2 1014 } else if (x1 == x2) {
WiredHome 19:3f82c1161fd2 1015 line(x1, y1, x2, y2);
WiredHome 19:3f82c1161fd2 1016 } else if (y1 == y2) {
WiredHome 19:3f82c1161fd2 1017 line(x1, y1, x2, y2);
WiredHome 19:3f82c1161fd2 1018 } else {
WiredHome 38:38d503b4fad6 1019 WriteCommandW(0x91, x1);
WiredHome 38:38d503b4fad6 1020 WriteCommandW(0x93, y1);
WiredHome 38:38d503b4fad6 1021 WriteCommandW(0x95, x2);
WiredHome 38:38d503b4fad6 1022 WriteCommandW(0x97, y2);
WiredHome 38:38d503b4fad6 1023 WriteCommandW(0xA1, radius1);
WiredHome 38:38d503b4fad6 1024 WriteCommandW(0xA3, radius2);
WiredHome 21:3c1efb192927 1025 // Should not need this...
WiredHome 38:38d503b4fad6 1026 WriteCommandW(0xA5, 0);
WiredHome 38:38d503b4fad6 1027 WriteCommandW(0xA7, 0);
WiredHome 19:3f82c1161fd2 1028 unsigned char drawCmd = 0x20; // Rounded Rectangle
WiredHome 19:3f82c1161fd2 1029 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 1030 drawCmd |= 0x40;
WiredHome 19:3f82c1161fd2 1031 WriteCommand(0xA0, drawCmd);
WiredHome 19:3f82c1161fd2 1032 WriteCommand(0xA0, 0x80 + drawCmd); // Start drawing.
WiredHome 66:468a11f05580 1033 _WaitWhileReg(0xA0, 0x80);
WiredHome 19:3f82c1161fd2 1034 }
WiredHome 19:3f82c1161fd2 1035 REGISTERPERFORMANCE(PRF_DRAWROUNDEDRECTANGLE);
WiredHome 19:3f82c1161fd2 1036 return ret;
WiredHome 19:3f82c1161fd2 1037 }
WiredHome 19:3f82c1161fd2 1038
WiredHome 44:207594dece70 1039
WiredHome 37:f19b7e7449dc 1040 RetCode_t RA8875::triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 37:f19b7e7449dc 1041 loc_t x3, loc_t y3, color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1042 {
WiredHome 20:6e2e4a8372eb 1043 RetCode_t ret;
WiredHome 20:6e2e4a8372eb 1044
WiredHome 19:3f82c1161fd2 1045 foreground(color);
WiredHome 20:6e2e4a8372eb 1046 ret = triangle(x1,y1,x2,y2,x3,y3,fillit);
WiredHome 20:6e2e4a8372eb 1047 return ret;
WiredHome 19:3f82c1161fd2 1048 }
WiredHome 19:3f82c1161fd2 1049
WiredHome 44:207594dece70 1050
WiredHome 37:f19b7e7449dc 1051 RetCode_t RA8875::filltriangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2,
WiredHome 37:f19b7e7449dc 1052 loc_t x3, loc_t y3, color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1053 {
WiredHome 20:6e2e4a8372eb 1054 RetCode_t ret;
WiredHome 20:6e2e4a8372eb 1055
WiredHome 19:3f82c1161fd2 1056 foreground(color);
WiredHome 20:6e2e4a8372eb 1057 ret = triangle(x1,y1,x2,y2,x3,y3,fillit);
WiredHome 20:6e2e4a8372eb 1058 return ret;
WiredHome 19:3f82c1161fd2 1059 }
WiredHome 19:3f82c1161fd2 1060
WiredHome 44:207594dece70 1061
WiredHome 37:f19b7e7449dc 1062 RetCode_t RA8875::triangle(loc_t x1, loc_t y1 ,loc_t x2, loc_t y2,
WiredHome 37:f19b7e7449dc 1063 loc_t x3, loc_t y3, fill_t fillit)
WiredHome 19:3f82c1161fd2 1064 {
WiredHome 19:3f82c1161fd2 1065 RetCode_t ret = noerror;
WiredHome 19:3f82c1161fd2 1066
WiredHome 19:3f82c1161fd2 1067 PERFORMANCE_RESET;
WiredHome 19:3f82c1161fd2 1068 if (x1 == x2 && y1 == y2 && x1 == x3 && y1 == y3) {
WiredHome 19:3f82c1161fd2 1069 pixel(x1, y1);
WiredHome 19:3f82c1161fd2 1070 } else {
WiredHome 38:38d503b4fad6 1071 WriteCommandW(0x91, x1);
WiredHome 38:38d503b4fad6 1072 WriteCommandW(0x93, y1);
WiredHome 38:38d503b4fad6 1073 WriteCommandW(0x95, x2);
WiredHome 38:38d503b4fad6 1074 WriteCommandW(0x97, y2);
WiredHome 38:38d503b4fad6 1075 WriteCommandW(0xA9, x3);
WiredHome 38:38d503b4fad6 1076 WriteCommandW(0xAB, y3);
WiredHome 19:3f82c1161fd2 1077 unsigned char drawCmd = 0x01; // Triangle
WiredHome 19:3f82c1161fd2 1078 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 1079 drawCmd |= 0x20;
WiredHome 19:3f82c1161fd2 1080 WriteCommand(0x90, drawCmd);
WiredHome 19:3f82c1161fd2 1081 WriteCommand(0x90, 0x80 + drawCmd); // Start drawing.
WiredHome 66:468a11f05580 1082 _WaitWhileReg(0x90, 0x80);
WiredHome 19:3f82c1161fd2 1083 }
WiredHome 19:3f82c1161fd2 1084 REGISTERPERFORMANCE(PRF_DRAWTRIANGLE);
WiredHome 19:3f82c1161fd2 1085 return ret;
WiredHome 19:3f82c1161fd2 1086 }
WiredHome 19:3f82c1161fd2 1087
WiredHome 37:f19b7e7449dc 1088 RetCode_t RA8875::circle(loc_t x, loc_t y, dim_t radius,
WiredHome 19:3f82c1161fd2 1089 color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1090 {
WiredHome 19:3f82c1161fd2 1091 foreground(color);
WiredHome 19:3f82c1161fd2 1092 return circle(x,y,radius,fillit);
WiredHome 19:3f82c1161fd2 1093 }
WiredHome 19:3f82c1161fd2 1094
WiredHome 44:207594dece70 1095
WiredHome 37:f19b7e7449dc 1096 RetCode_t RA8875::fillcircle(loc_t x, loc_t y, dim_t radius,
WiredHome 19:3f82c1161fd2 1097 color_t color, fill_t fillit)
WiredHome 19:3f82c1161fd2 1098 {
WiredHome 19:3f82c1161fd2 1099 foreground(color);
WiredHome 19:3f82c1161fd2 1100 return circle(x,y,radius,fillit);
WiredHome 19:3f82c1161fd2 1101 }
WiredHome 19:3f82c1161fd2 1102
WiredHome 44:207594dece70 1103
WiredHome 37:f19b7e7449dc 1104 RetCode_t RA8875::circle(loc_t x, loc_t y, dim_t radius, fill_t fillit)
WiredHome 19:3f82c1161fd2 1105 {
WiredHome 19:3f82c1161fd2 1106 RetCode_t ret = noerror;
WiredHome 19:3f82c1161fd2 1107
WiredHome 19:3f82c1161fd2 1108 PERFORMANCE_RESET;
WiredHome 19:3f82c1161fd2 1109 if (radius <= 0) {
WiredHome 19:3f82c1161fd2 1110 ret = bad_parameter;
WiredHome 19:3f82c1161fd2 1111 } else if (radius == 1) {
WiredHome 19:3f82c1161fd2 1112 pixel(x,y);
WiredHome 19:3f82c1161fd2 1113 } else {
WiredHome 38:38d503b4fad6 1114 WriteCommandW(0x99, x);
WiredHome 38:38d503b4fad6 1115 WriteCommandW(0x9B, y);
WiredHome 19:3f82c1161fd2 1116 WriteCommand(0x9d, radius & 0xFF);
WiredHome 19:3f82c1161fd2 1117 unsigned char drawCmd = 0x00; // Circle
WiredHome 19:3f82c1161fd2 1118 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 1119 drawCmd |= 0x20;
WiredHome 19:3f82c1161fd2 1120 WriteCommand(0x90, drawCmd);
WiredHome 19:3f82c1161fd2 1121 WriteCommand(0x90, 0x40 + drawCmd); // Start drawing.
WiredHome 66:468a11f05580 1122 _WaitWhileReg(0x90, 0x40);
WiredHome 19:3f82c1161fd2 1123 }
WiredHome 19:3f82c1161fd2 1124 REGISTERPERFORMANCE(PRF_DRAWCIRCLE);
WiredHome 19:3f82c1161fd2 1125 return ret;
WiredHome 19:3f82c1161fd2 1126 }
WiredHome 19:3f82c1161fd2 1127
WiredHome 44:207594dece70 1128
WiredHome 37:f19b7e7449dc 1129 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 1130 {
WiredHome 19:3f82c1161fd2 1131 foreground(color);
WiredHome 25:9556a3a9b7cc 1132 return ellipse(x,y,radius1,radius2,fillit);
WiredHome 19:3f82c1161fd2 1133 }
WiredHome 19:3f82c1161fd2 1134
WiredHome 44:207594dece70 1135
WiredHome 37:f19b7e7449dc 1136 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 1137 {
WiredHome 25:9556a3a9b7cc 1138 foreground(color);
WiredHome 25:9556a3a9b7cc 1139 return ellipse(x,y,radius1,radius2,fillit);
WiredHome 25:9556a3a9b7cc 1140 }
WiredHome 44:207594dece70 1141
WiredHome 25:9556a3a9b7cc 1142
WiredHome 37:f19b7e7449dc 1143 RetCode_t RA8875::ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, fill_t fillit)
WiredHome 19:3f82c1161fd2 1144 {
WiredHome 19:3f82c1161fd2 1145 RetCode_t ret = noerror;
WiredHome 19:3f82c1161fd2 1146
WiredHome 19:3f82c1161fd2 1147 PERFORMANCE_RESET;
WiredHome 25:9556a3a9b7cc 1148 if (radius1 <= 0 || radius2 <= 0) {
WiredHome 19:3f82c1161fd2 1149 ; // do nothing
WiredHome 25:9556a3a9b7cc 1150 } else if (radius1 == 1 && radius2 == 1) {
WiredHome 19:3f82c1161fd2 1151 pixel(x, y);
WiredHome 19:3f82c1161fd2 1152 } else {
WiredHome 38:38d503b4fad6 1153 WriteCommandW(0xA5, x);
WiredHome 38:38d503b4fad6 1154 WriteCommandW(0xA7, y);
WiredHome 38:38d503b4fad6 1155 WriteCommandW(0xA1, radius1);
WiredHome 38:38d503b4fad6 1156 WriteCommandW(0xA3, radius2);
WiredHome 19:3f82c1161fd2 1157 unsigned char drawCmd = 0x00; // Ellipse
WiredHome 19:3f82c1161fd2 1158 if (fillit == FILL)
WiredHome 19:3f82c1161fd2 1159 drawCmd |= 0x40;
WiredHome 19:3f82c1161fd2 1160 WriteCommand(0xA0, drawCmd);
WiredHome 19:3f82c1161fd2 1161 WriteCommand(0xA0, 0x80 + drawCmd); // Start drawing.
WiredHome 66:468a11f05580 1162 _WaitWhileReg(0xA0, 0x80);
WiredHome 19:3f82c1161fd2 1163 }
WiredHome 19:3f82c1161fd2 1164 REGISTERPERFORMANCE(PRF_DRAWELLIPSE);
WiredHome 19:3f82c1161fd2 1165 return ret;
WiredHome 19:3f82c1161fd2 1166 }
WiredHome 19:3f82c1161fd2 1167
WiredHome 44:207594dece70 1168
WiredHome 68:ab08efabfc88 1169 RetCode_t RA8875::frequency(unsigned long Hz, unsigned long Hz2)
WiredHome 19:3f82c1161fd2 1170 {
WiredHome 66:468a11f05580 1171 spiwritefreq = Hz;
WiredHome 68:ab08efabfc88 1172 if (Hz2 != 0)
WiredHome 68:ab08efabfc88 1173 spireadfreq = Hz2;
WiredHome 68:ab08efabfc88 1174 else
WiredHome 68:ab08efabfc88 1175 spireadfreq = Hz/2;
WiredHome 68:ab08efabfc88 1176 _setWriteSpeed(true);
WiredHome 19:3f82c1161fd2 1177 // __ ___
WiredHome 19:3f82c1161fd2 1178 // Clock ___A Rising edge latched
WiredHome 19:3f82c1161fd2 1179 // ___ ____
WiredHome 19:3f82c1161fd2 1180 // Data ___X____
WiredHome 19:3f82c1161fd2 1181 spi.format(8, 3); // 8 bits and clock to data phase 0
WiredHome 19:3f82c1161fd2 1182 return noerror;
WiredHome 19:3f82c1161fd2 1183 }
WiredHome 19:3f82c1161fd2 1184
WiredHome 68:ab08efabfc88 1185 void RA8875::_setWriteSpeed(bool writeSpeed)
WiredHome 68:ab08efabfc88 1186 {
WiredHome 68:ab08efabfc88 1187 if (writeSpeed) {
WiredHome 68:ab08efabfc88 1188 spi.frequency(spiwritefreq);
WiredHome 68:ab08efabfc88 1189 spiWriteSpeed = true;
WiredHome 68:ab08efabfc88 1190 } else {
WiredHome 68:ab08efabfc88 1191 spi.frequency(spireadfreq);
WiredHome 68:ab08efabfc88 1192 spiWriteSpeed = false;
WiredHome 68:ab08efabfc88 1193 }
WiredHome 68:ab08efabfc88 1194 }
WiredHome 44:207594dece70 1195
WiredHome 19:3f82c1161fd2 1196 RetCode_t RA8875::Power(bool on)
WiredHome 19:3f82c1161fd2 1197 {
WiredHome 19:3f82c1161fd2 1198 WriteCommand(0x01, (on) ? 0x80 : 0x00);
WiredHome 19:3f82c1161fd2 1199 return noerror;
WiredHome 19:3f82c1161fd2 1200 }
WiredHome 19:3f82c1161fd2 1201
WiredHome 44:207594dece70 1202
WiredHome 19:3f82c1161fd2 1203 RetCode_t RA8875::Reset(void)
WiredHome 19:3f82c1161fd2 1204 {
WiredHome 19:3f82c1161fd2 1205 WriteCommand(0x01, 0x01); // Apply Display Off, Reset
WiredHome 19:3f82c1161fd2 1206 wait_ms(2); // no idea if I need to wait, or how long
WiredHome 19:3f82c1161fd2 1207 WriteCommand(0x01, 0x00); // Display off, Remove reset
WiredHome 19:3f82c1161fd2 1208 wait_ms(2); // no idea if I need to wait, or how long
WiredHome 43:3becae133285 1209 init(RA8875_DISPLAY_WIDTH, RA8875_DISPLAY_HEIGHT, RA8875_COLORDEPTH_BPP);
WiredHome 19:3f82c1161fd2 1210 return noerror;
WiredHome 19:3f82c1161fd2 1211 }
WiredHome 19:3f82c1161fd2 1212
WiredHome 19:3f82c1161fd2 1213
WiredHome 19:3f82c1161fd2 1214 RetCode_t RA8875::Backlight_u8(unsigned char brightness)
WiredHome 19:3f82c1161fd2 1215 {
WiredHome 19:3f82c1161fd2 1216 static bool is_enabled = false;
WiredHome 19:3f82c1161fd2 1217 if (brightness == 0) {
WiredHome 19:3f82c1161fd2 1218 WriteCommand(0x8a); // Disable the PWM
WiredHome 19:3f82c1161fd2 1219 WriteData(0x00);
WiredHome 19:3f82c1161fd2 1220 is_enabled = false;
WiredHome 19:3f82c1161fd2 1221 } else if (!is_enabled) {
WiredHome 19:3f82c1161fd2 1222 WriteCommand(0x8a); // Enable the PWM
WiredHome 19:3f82c1161fd2 1223 WriteData(0x80);
WiredHome 19:3f82c1161fd2 1224 WriteCommand(0x8a); // Not sure why this is needed, but following the pattern
WiredHome 19:3f82c1161fd2 1225 WriteData(0x81); // open PWM (SYS_CLK / 2 as best I can tell)
WiredHome 19:3f82c1161fd2 1226 is_enabled = true;
WiredHome 19:3f82c1161fd2 1227 }
WiredHome 19:3f82c1161fd2 1228 WriteCommand(0x8b, brightness); // Brightness parameter 0xff-0x00
WiredHome 19:3f82c1161fd2 1229 return noerror;
WiredHome 19:3f82c1161fd2 1230 }
WiredHome 19:3f82c1161fd2 1231
WiredHome 44:207594dece70 1232
WiredHome 19:3f82c1161fd2 1233 RetCode_t RA8875::Backlight(float brightness)
WiredHome 19:3f82c1161fd2 1234 {
WiredHome 19:3f82c1161fd2 1235 unsigned char b;
WiredHome 19:3f82c1161fd2 1236
WiredHome 29:422616aa04bd 1237 if (brightness >= 1.0)
WiredHome 19:3f82c1161fd2 1238 b = 255;
WiredHome 29:422616aa04bd 1239 else if (brightness <= 0.0)
WiredHome 19:3f82c1161fd2 1240 b = 0;
WiredHome 19:3f82c1161fd2 1241 else
WiredHome 19:3f82c1161fd2 1242 b = (unsigned char)(brightness * 255);
WiredHome 19:3f82c1161fd2 1243 return Backlight_u8(b);
WiredHome 19:3f82c1161fd2 1244 }
WiredHome 19:3f82c1161fd2 1245
WiredHome 44:207594dece70 1246
WiredHome 19:3f82c1161fd2 1247 RetCode_t RA8875::set_font(const unsigned char * _font)
WiredHome 19:3f82c1161fd2 1248 {
WiredHome 37:f19b7e7449dc 1249 if (font && ! _font) {
WiredHome 37:f19b7e7449dc 1250 SetTextCursor(cursor_x, cursor_y); // soft-font cursor -> hw cursor
WiredHome 37:f19b7e7449dc 1251 }
WiredHome 19:3f82c1161fd2 1252 font = _font;
WiredHome 29:422616aa04bd 1253 GraphicsDisplay::set_font(_font);
WiredHome 29:422616aa04bd 1254 return noerror; // trusting them, but it might be good to put some checks in here...
WiredHome 19:3f82c1161fd2 1255 }
WiredHome 19:3f82c1161fd2 1256
WiredHome 44:207594dece70 1257
WiredHome 19:3f82c1161fd2 1258 RetCode_t RA8875::background(color_t color)
WiredHome 19:3f82c1161fd2 1259 {
WiredHome 37:f19b7e7449dc 1260 GraphicsDisplay::background(color);
WiredHome 19:3f82c1161fd2 1261 WriteCommand(0x60, (color>>11)); // BGCR0
WiredHome 19:3f82c1161fd2 1262 WriteCommand(0x61, (unsigned char)(color>>5)); // BGCR0
WiredHome 19:3f82c1161fd2 1263 WriteCommand(0x62, (unsigned char)(color)); // BGCR0
WiredHome 19:3f82c1161fd2 1264 return noerror;
WiredHome 19:3f82c1161fd2 1265 }
WiredHome 19:3f82c1161fd2 1266
WiredHome 44:207594dece70 1267
WiredHome 19:3f82c1161fd2 1268 RetCode_t RA8875::background(unsigned char r, unsigned char g, unsigned char b)
WiredHome 19:3f82c1161fd2 1269 {
WiredHome 37:f19b7e7449dc 1270 background(RGB(r,g,b));
WiredHome 37:f19b7e7449dc 1271 // WriteCommand(0x60, r);
WiredHome 37:f19b7e7449dc 1272 // WriteCommand(0x61, g);
WiredHome 37:f19b7e7449dc 1273 // WriteCommand(0x62, b);
WiredHome 19:3f82c1161fd2 1274 return noerror;
WiredHome 19:3f82c1161fd2 1275 }
WiredHome 19:3f82c1161fd2 1276
WiredHome 44:207594dece70 1277
WiredHome 19:3f82c1161fd2 1278 RetCode_t RA8875::foreground(color_t color)
WiredHome 19:3f82c1161fd2 1279 {
WiredHome 37:f19b7e7449dc 1280 GraphicsDisplay::foreground(color);
WiredHome 19:3f82c1161fd2 1281 WriteCommand(0x63, (unsigned char)(color>>11));
WiredHome 19:3f82c1161fd2 1282 WriteCommand(0x64, (unsigned char)(color>>5));
WiredHome 19:3f82c1161fd2 1283 WriteCommand(0x65, (unsigned char)(color));
WiredHome 19:3f82c1161fd2 1284 return noerror;
WiredHome 19:3f82c1161fd2 1285 }
WiredHome 19:3f82c1161fd2 1286
WiredHome 44:207594dece70 1287
WiredHome 37:f19b7e7449dc 1288 RetCode_t RA8875::foreground(unsigned char r, unsigned char g, unsigned char b)
WiredHome 19:3f82c1161fd2 1289 {
WiredHome 37:f19b7e7449dc 1290 foreground(RGB(r,g,b));
WiredHome 37:f19b7e7449dc 1291 // WriteCommand(0x63, r);
WiredHome 37:f19b7e7449dc 1292 // WriteCommand(0x64, g);
WiredHome 37:f19b7e7449dc 1293 // WriteCommand(0x65, b);
WiredHome 19:3f82c1161fd2 1294 return noerror;
WiredHome 19:3f82c1161fd2 1295 }
WiredHome 19:3f82c1161fd2 1296
WiredHome 44:207594dece70 1297
WiredHome 37:f19b7e7449dc 1298 color_t RA8875::GetForeColor(void)
WiredHome 19:3f82c1161fd2 1299 {
WiredHome 19:3f82c1161fd2 1300 color_t color;
WiredHome 19:3f82c1161fd2 1301
WiredHome 19:3f82c1161fd2 1302 color = (ReadCommand(0x63) & 0x1F) << 11;
WiredHome 19:3f82c1161fd2 1303 color |= (ReadCommand(0x64) & 0x3F) << 5;
WiredHome 19:3f82c1161fd2 1304 color |= (ReadCommand(0x65) & 0x1F);
WiredHome 19:3f82c1161fd2 1305 return color;
WiredHome 19:3f82c1161fd2 1306 }
WiredHome 19:3f82c1161fd2 1307
WiredHome 44:207594dece70 1308
WiredHome 19:3f82c1161fd2 1309 color_t RA8875::DOSColor(int i)
WiredHome 19:3f82c1161fd2 1310 {
WiredHome 19:3f82c1161fd2 1311 const color_t colors[16] =
WiredHome 19:3f82c1161fd2 1312 {
WiredHome 19:3f82c1161fd2 1313 Black, Blue, Green, Cyan,
WiredHome 19:3f82c1161fd2 1314 Red, Magenta, Brown, Gray,
WiredHome 19:3f82c1161fd2 1315 Charcoal, BrightBlue, BrightGreen, BrightCyan,
WiredHome 19:3f82c1161fd2 1316 Orange, Pink, Yellow, White
WiredHome 19:3f82c1161fd2 1317 };
WiredHome 19:3f82c1161fd2 1318 if (i < 16)
WiredHome 19:3f82c1161fd2 1319 return colors[i];
WiredHome 19:3f82c1161fd2 1320 else
WiredHome 19:3f82c1161fd2 1321 return 0;
WiredHome 19:3f82c1161fd2 1322 }
WiredHome 19:3f82c1161fd2 1323
WiredHome 44:207594dece70 1324
WiredHome 19:3f82c1161fd2 1325 const char * RA8875::DOSColorNames(int i)
WiredHome 19:3f82c1161fd2 1326 {
WiredHome 19:3f82c1161fd2 1327 const char * names[16] =
WiredHome 19:3f82c1161fd2 1328 {
WiredHome 19:3f82c1161fd2 1329 "Black", "Blue", "Green", "Cyan",
WiredHome 19:3f82c1161fd2 1330 "Red", "Magenta", "Brown", "Gray",
WiredHome 19:3f82c1161fd2 1331 "Charcoal", "BrightBlue", "BrightGreen", "BrightCyan",
WiredHome 19:3f82c1161fd2 1332 "Orange", "Pink", "Yellow", "White"
WiredHome 19:3f82c1161fd2 1333 };
WiredHome 19:3f82c1161fd2 1334 if (i < 16)
WiredHome 19:3f82c1161fd2 1335 return names[i];
WiredHome 19:3f82c1161fd2 1336 else
WiredHome 19:3f82c1161fd2 1337 return NULL;
WiredHome 19:3f82c1161fd2 1338 }
WiredHome 19:3f82c1161fd2 1339
WiredHome 19:3f82c1161fd2 1340
WiredHome 19:3f82c1161fd2 1341 ///////////////////////////////////////////////////////////////
WiredHome 19:3f82c1161fd2 1342 // Private functions
WiredHome 19:3f82c1161fd2 1343
WiredHome 19:3f82c1161fd2 1344 unsigned char RA8875::spiwrite(unsigned char data)
WiredHome 19:3f82c1161fd2 1345 {
WiredHome 19:3f82c1161fd2 1346 unsigned char retval;
WiredHome 19:3f82c1161fd2 1347
WiredHome 68:ab08efabfc88 1348 if (!spiWriteSpeed)
WiredHome 68:ab08efabfc88 1349 _setWriteSpeed(true);
WiredHome 19:3f82c1161fd2 1350 retval = spi.write(data);
WiredHome 19:3f82c1161fd2 1351 return retval;
WiredHome 19:3f82c1161fd2 1352 }
WiredHome 19:3f82c1161fd2 1353
WiredHome 44:207594dece70 1354
WiredHome 19:3f82c1161fd2 1355 unsigned char RA8875::spiread(void)
WiredHome 19:3f82c1161fd2 1356 {
WiredHome 19:3f82c1161fd2 1357 unsigned char retval;
WiredHome 19:3f82c1161fd2 1358 unsigned char data = 0;
WiredHome 19:3f82c1161fd2 1359
WiredHome 68:ab08efabfc88 1360 if (spiWriteSpeed)
WiredHome 68:ab08efabfc88 1361 _setWriteSpeed(false);
WiredHome 19:3f82c1161fd2 1362 retval = spi.write(data);
WiredHome 19:3f82c1161fd2 1363 return retval;
WiredHome 19:3f82c1161fd2 1364 }
WiredHome 19:3f82c1161fd2 1365
WiredHome 44:207594dece70 1366
WiredHome 19:3f82c1161fd2 1367 RetCode_t RA8875::select(bool chipsel)
WiredHome 19:3f82c1161fd2 1368 {
WiredHome 19:3f82c1161fd2 1369 cs = (chipsel == true) ? 0 : 1;
WiredHome 19:3f82c1161fd2 1370 return noerror;
WiredHome 19:3f82c1161fd2 1371 }
WiredHome 19:3f82c1161fd2 1372
WiredHome 44:207594dece70 1373
WiredHome 43:3becae133285 1374 RetCode_t RA8875::init(int width, int height, int color_bpp)
WiredHome 19:3f82c1161fd2 1375 {
WiredHome 19:3f82c1161fd2 1376 Backlight_u8(0);
WiredHome 66:468a11f05580 1377 WriteCommand(0x88, 0x0B); // PLLC1 - Phase Lock Loop registers
WiredHome 19:3f82c1161fd2 1378 wait_ms(1);
WiredHome 19:3f82c1161fd2 1379 WriteCommand(0x89, 0x02);
WiredHome 19:3f82c1161fd2 1380 wait_ms(1);
WiredHome 19:3f82c1161fd2 1381
WiredHome 23:a50ded45dbaf 1382 // System Config Register (SYSR)
WiredHome 43:3becae133285 1383 if (color_bpp == 16) {
WiredHome 43:3becae133285 1384 WriteCommand(0x10, 0x0C); // 16-bpp (65K colors) color depth, 8-bit interface
WiredHome 43:3becae133285 1385 } else { // color_bpp == 8
WiredHome 43:3becae133285 1386 WriteCommand(0x10, 0x00); // 8-bpp (256 colors)
WiredHome 43:3becae133285 1387 }
WiredHome 23:a50ded45dbaf 1388 // Pixel Clock Setting Register (PCSR)
WiredHome 37:f19b7e7449dc 1389 WriteCommand(0x04, 0x82); // PDAT on PCLK falling edge, PCLK = 4 x System Clock
WiredHome 19:3f82c1161fd2 1390 wait_ms(1);
WiredHome 19:3f82c1161fd2 1391
WiredHome 19:3f82c1161fd2 1392 // Horizontal Settings
WiredHome 43:3becae133285 1393 WriteCommand(0x14, width/8 - 1); //HDWR//Horizontal Display Width Setting Bit[6:0]
WiredHome 43:3becae133285 1394 WriteCommand(0x15, 0x02); //HNDFCR//Horizontal Non-Display Period fine tune Bit[3:0]
WiredHome 43:3becae133285 1395 WriteCommand(0x16, 0x03); //HNDR//Horizontal Non-Display Period Bit[4:0]
WiredHome 43:3becae133285 1396 WriteCommand(0x17, 0x01); //HSTR//HSYNC Start Position[4:0]
WiredHome 43:3becae133285 1397 WriteCommand(0x18, 0x03); //HPWR//HSYNC Polarity ,The period width of HSYNC.
WiredHome 19:3f82c1161fd2 1398
WiredHome 19:3f82c1161fd2 1399 // Vertical Settings
WiredHome 43:3becae133285 1400 WriteCommand(0x19, (height-1)&0xFF); //VDHR0 //Vertical Display Height Bit [7:0]
WiredHome 43:3becae133285 1401 WriteCommand(0x1a, (height-1)>>8); //VDHR1 //Vertical Display Height Bit [8]
WiredHome 43:3becae133285 1402 WriteCommand(0x1b, 0x0F); //VNDR0 //Vertical Non-Display Period Bit [7:0]
WiredHome 43:3becae133285 1403 WriteCommand(0x1c, 0x00); //VNDR1 //Vertical Non-Display Period Bit [8]
WiredHome 43:3becae133285 1404 WriteCommand(0x1d, 0x0e); //VSTR0 //VSYNC Start Position[7:0]
WiredHome 43:3becae133285 1405 WriteCommand(0x1e, 0x06); //VSTR1 //VSYNC Start Position[8]
WiredHome 43:3becae133285 1406 WriteCommand(0x1f, 0x01); //VPWR //VSYNC Polarity ,VSYNC Pulse Width[6:0]
WiredHome 19:3f82c1161fd2 1407
WiredHome 43:3becae133285 1408 if (width >= 800 && height >= 480 && color_bpp > 8) {
WiredHome 43:3becae133285 1409 WriteCommand(0x20, 0x00); // DPCR - 1-layer mode when the resolution is too high
WiredHome 43:3becae133285 1410 } else {
WiredHome 43:3becae133285 1411 WriteCommand(0x20, 0x80); // DPCR - 2-layer mode
WiredHome 43:3becae133285 1412 }
WiredHome 43:3becae133285 1413
WiredHome 50:2c4f474a2453 1414 // Set display image to Blue on Black as default
WiredHome 43:3becae133285 1415 window(0,0, width, height); // Initialize to full screen
WiredHome 24:8ca861acf12d 1416 SetTextCursorControl();
WiredHome 28:ed102fc442c4 1417 foreground(Blue);
WiredHome 19:3f82c1161fd2 1418 background(Black);
WiredHome 50:2c4f474a2453 1419 SelectDrawingLayer(1);
WiredHome 50:2c4f474a2453 1420 cls();
WiredHome 50:2c4f474a2453 1421 SelectDrawingLayer(0);
WiredHome 19:3f82c1161fd2 1422 cls();
WiredHome 19:3f82c1161fd2 1423 return noerror;
WiredHome 19:3f82c1161fd2 1424 }
WiredHome 19:3f82c1161fd2 1425
WiredHome 72:ecffe56af969 1426 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 1427 {
WiredHome 72:ecffe56af969 1428 uint16_t curLayer = GetDrawingLayer();
WiredHome 72:ecffe56af969 1429 RetCode_t ret = SelectDrawingLayer(layer);
WiredHome 72:ecffe56af969 1430 if (ret == noerror) {
WiredHome 72:ecffe56af969 1431 ret = PrintScreen(x, y, w, h, Name_BMP);
WiredHome 72:ecffe56af969 1432 }
WiredHome 72:ecffe56af969 1433 SelectDrawingLayer(curLayer);
WiredHome 72:ecffe56af969 1434 return ret;
WiredHome 72:ecffe56af969 1435 }
WiredHome 72:ecffe56af969 1436
WiredHome 72:ecffe56af969 1437 RetCode_t RA8875::PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP)
WiredHome 72:ecffe56af969 1438 {
WiredHome 72:ecffe56af969 1439 BITMAPFILEHEADER BMP_Header;
WiredHome 72:ecffe56af969 1440 BITMAPINFOHEADER BMP_Info;
WiredHome 72:ecffe56af969 1441
WiredHome 72:ecffe56af969 1442 INFO("(%d,%d) - (%d,%d) %s", x,y,w,h,Name_BMP);
WiredHome 72:ecffe56af969 1443 if (x >= 0 && x < width()
WiredHome 72:ecffe56af969 1444 && y >= 0 && y < height()
WiredHome 72:ecffe56af969 1445 && w > 0 && x + w <= width()
WiredHome 72:ecffe56af969 1446 && h > 0 && y + h <= height()) {
WiredHome 72:ecffe56af969 1447
WiredHome 72:ecffe56af969 1448 BMP_Header.bfType = BF_TYPE;
WiredHome 72:ecffe56af969 1449 BMP_Header.bfSize = (w * h * sizeof(RGBQUAD)) + sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 72:ecffe56af969 1450 BMP_Header.bfReserved1 = 0;
WiredHome 72:ecffe56af969 1451 BMP_Header.bfReserved2 = 0;
WiredHome 72:ecffe56af969 1452 BMP_Header.bfOffBits = sizeof(BMP_Header) + sizeof(BMP_Header);
WiredHome 72:ecffe56af969 1453
WiredHome 72:ecffe56af969 1454 BMP_Info.biSize = sizeof(BMP_Info);
WiredHome 72:ecffe56af969 1455 BMP_Info.biWidth = w;
WiredHome 72:ecffe56af969 1456 BMP_Info.biHeight = h;
WiredHome 72:ecffe56af969 1457 BMP_Info.biPlanes = 1;
WiredHome 72:ecffe56af969 1458 BMP_Info.biBitCount = 24;
WiredHome 72:ecffe56af969 1459 BMP_Info.biCompression = BI_RGB;
WiredHome 72:ecffe56af969 1460 BMP_Info.biSizeImage = 0;
WiredHome 72:ecffe56af969 1461 BMP_Info.biXPelsPerMeter = 0;
WiredHome 72:ecffe56af969 1462 BMP_Info.biYPelsPerMeter = 0;
WiredHome 72:ecffe56af969 1463 BMP_Info.biClrUsed = 0;
WiredHome 72:ecffe56af969 1464 BMP_Info.biClrImportant = 0;
WiredHome 72:ecffe56af969 1465
WiredHome 72:ecffe56af969 1466 INFO("Writing {%s}", Name_BMP);
WiredHome 72:ecffe56af969 1467 FILE *Image = fopen(Name_BMP, "wb");
WiredHome 72:ecffe56af969 1468 if (!Image) {
WiredHome 72:ecffe56af969 1469 ERR("File not found");
WiredHome 72:ecffe56af969 1470 return(file_not_found);
WiredHome 72:ecffe56af969 1471 }
WiredHome 72:ecffe56af969 1472
WiredHome 72:ecffe56af969 1473 // Be optimistic - don't check for errors.
WiredHome 72:ecffe56af969 1474 //HexDump("BMP_Header", (uint8_t *)&BMP_Header, sizeof(BMP_Header));
WiredHome 72:ecffe56af969 1475 fwrite(&BMP_Header, sizeof(char), sizeof(BMP_Header), Image);
WiredHome 72:ecffe56af969 1476 //INFO("fwrite returned %d", r);
WiredHome 72:ecffe56af969 1477
WiredHome 72:ecffe56af969 1478 //HexDump("BMP_Info", (uint8_t *)&BMP_Info, sizeof(BMP_Info));
WiredHome 72:ecffe56af969 1479 fwrite(&BMP_Info, sizeof(char), sizeof(BMP_Info), Image);
WiredHome 72:ecffe56af969 1480 //INFO("fwrite returned %d", r);
WiredHome 72:ecffe56af969 1481
WiredHome 72:ecffe56af969 1482 int lineBufSize = ((24 * w + 7)/8);
WiredHome 72:ecffe56af969 1483 uint8_t * lineBuffer = (uint8_t *)malloc(lineBufSize);
WiredHome 72:ecffe56af969 1484 if (lineBuffer == NULL) {
WiredHome 72:ecffe56af969 1485 fclose(Image);
WiredHome 72:ecffe56af969 1486 ERR("Not enough RAM for lineBuffer");
WiredHome 72:ecffe56af969 1487 return(not_enough_ram);
WiredHome 72:ecffe56af969 1488 }
WiredHome 72:ecffe56af969 1489 color_t * pixelBuffer = (color_t *)malloc(w * sizeof(color_t));
WiredHome 72:ecffe56af969 1490 if (pixelBuffer == NULL) {
WiredHome 72:ecffe56af969 1491 fclose(Image);
WiredHome 72:ecffe56af969 1492 free(lineBuffer);
WiredHome 72:ecffe56af969 1493 ERR("Not enough RAM for pixelBuffer");
WiredHome 72:ecffe56af969 1494 return(not_enough_ram);
WiredHome 72:ecffe56af969 1495 }
WiredHome 72:ecffe56af969 1496
WiredHome 72:ecffe56af969 1497 // Read the display from the last line toward the top
WiredHome 72:ecffe56af969 1498 // so we can write the file in one pass.
WiredHome 72:ecffe56af969 1499 for (int j = h - 1; j >= 0; j--) {
WiredHome 72:ecffe56af969 1500 // Read one line of pixels to a local buffer
WiredHome 72:ecffe56af969 1501 if (getPixelStream(pixelBuffer, w, x,y+j) != noerror) {
WiredHome 72:ecffe56af969 1502 ERR("getPixelStream error, and no recovery handler...");
WiredHome 72:ecffe56af969 1503 }
WiredHome 72:ecffe56af969 1504 // Convert the local buffer to RGBQUAD format
WiredHome 72:ecffe56af969 1505 int lb = 0;
WiredHome 72:ecffe56af969 1506 for (int i=0; i<w; i++) {
WiredHome 72:ecffe56af969 1507 color_t pixel = pixelBuffer[x+i];
WiredHome 72:ecffe56af969 1508 // Scale to 24-bits
WiredHome 72:ecffe56af969 1509 RGBQUAD q = RGB16ToRGBQuad(pixel);
WiredHome 72:ecffe56af969 1510 lineBuffer[lb++] = q.rgbBlue;
WiredHome 72:ecffe56af969 1511 lineBuffer[lb++] = q.rgbGreen;
WiredHome 72:ecffe56af969 1512 lineBuffer[lb++] = q.rgbRed;
WiredHome 72:ecffe56af969 1513 }
WiredHome 72:ecffe56af969 1514 // Write to disk
WiredHome 72:ecffe56af969 1515 //HexDump("Line", lineBuffer, lineBufSize);
WiredHome 72:ecffe56af969 1516 fwrite(lineBuffer, sizeof(char), lb, Image);
WiredHome 72:ecffe56af969 1517 }
WiredHome 72:ecffe56af969 1518 fclose(Image);
WiredHome 72:ecffe56af969 1519 free(pixelBuffer); // don't leak memory.
WiredHome 72:ecffe56af969 1520 free(lineBuffer);
WiredHome 72:ecffe56af969 1521 INFO("Image closed");
WiredHome 72:ecffe56af969 1522 return noerror;
WiredHome 72:ecffe56af969 1523 } else {
WiredHome 72:ecffe56af969 1524 return bad_parameter;
WiredHome 72:ecffe56af969 1525 }
WiredHome 72:ecffe56af969 1526 }
WiredHome 72:ecffe56af969 1527
WiredHome 72:ecffe56af969 1528
WiredHome 72:ecffe56af969 1529 // ##########################################################################
WiredHome 72:ecffe56af969 1530 // ##########################################################################
WiredHome 72:ecffe56af969 1531 // ##########################################################################
WiredHome 72:ecffe56af969 1532
WiredHome 23:a50ded45dbaf 1533 #ifdef TESTENABLE
WiredHome 23:a50ded45dbaf 1534
WiredHome 37:f19b7e7449dc 1535 #include "Arial12x12.h"
WiredHome 37:f19b7e7449dc 1536 #include "Small_6.h"
WiredHome 37:f19b7e7449dc 1537
WiredHome 23:a50ded45dbaf 1538 // ______________ ______________ ______________ _______________
WiredHome 23:a50ded45dbaf 1539 // /_____ _____/ / ___________/ / ___________/ /_____ ______/
WiredHome 23:a50ded45dbaf 1540 // / / / / / / / /
WiredHome 23:a50ded45dbaf 1541 // / / / /___ / /__________ / /
WiredHome 23:a50ded45dbaf 1542 // / / / ____/ /__________ / / /
WiredHome 23:a50ded45dbaf 1543 // / / / / / / / /
WiredHome 23:a50ded45dbaf 1544 // / / / /__________ ___________/ / / /
WiredHome 23:a50ded45dbaf 1545 // /__/ /_____________/ /_____________/ /__/
WiredHome 23:a50ded45dbaf 1546 //
WiredHome 23:a50ded45dbaf 1547 // Everything from here down is test code.
WiredHome 41:2956a0a221e5 1548 bool SuppressSlowStuff = false;
WiredHome 23:a50ded45dbaf 1549
WiredHome 44:207594dece70 1550
WiredHome 49:c5182231d1b9 1551 void TextWrapTest(RA8875 & display, Serial & pc)
WiredHome 49:c5182231d1b9 1552 {
WiredHome 49:c5182231d1b9 1553 if (!SuppressSlowStuff)
WiredHome 49:c5182231d1b9 1554 pc.printf("Text Wrap Test\r\n");
WiredHome 49:c5182231d1b9 1555 display.background(Black);
WiredHome 49:c5182231d1b9 1556 display.foreground(Blue);
WiredHome 49:c5182231d1b9 1557 display.cls();
WiredHome 49:c5182231d1b9 1558 display.Backlight_u8(255);
WiredHome 49:c5182231d1b9 1559 display.puts(0,0, "Text Wrap Test.\r\n");
WiredHome 52:e6039a823420 1560 for (int i=1; i<60; i++) {
WiredHome 52:e6039a823420 1561 display.printf("L%2d\n", i % 17);
WiredHome 49:c5182231d1b9 1562 if (!SuppressSlowStuff)
WiredHome 52:e6039a823420 1563 wait_ms(100);
WiredHome 49:c5182231d1b9 1564 }
WiredHome 49:c5182231d1b9 1565 if (!SuppressSlowStuff)
WiredHome 49:c5182231d1b9 1566 wait_ms(3000);
WiredHome 49:c5182231d1b9 1567 }
WiredHome 49:c5182231d1b9 1568
WiredHome 23:a50ded45dbaf 1569 void TextCursorTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 1570 {
WiredHome 37:f19b7e7449dc 1571 const char * iCursor = "The I-Beam cursor should be visible for this text.\r\n";
WiredHome 37:f19b7e7449dc 1572 const char * uCursor = "The Underscore cursor should be visible for this text.\r\n";
WiredHome 37:f19b7e7449dc 1573 const char * bCursor = "The Block cursor should be visible for this text.\r\n";
WiredHome 37:f19b7e7449dc 1574 const char * bbCursor = "The Blinking Block cursor should be visible for this text.\r\n";
WiredHome 23:a50ded45dbaf 1575 const char * p;
WiredHome 41:2956a0a221e5 1576 int delay = 100;
WiredHome 23:a50ded45dbaf 1577
WiredHome 41:2956a0a221e5 1578 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 1579 pc.printf("Text Cursor Test\r\n");
WiredHome 41:2956a0a221e5 1580 else
WiredHome 41:2956a0a221e5 1581 delay = 0;
WiredHome 23:a50ded45dbaf 1582 display.background(Black);
WiredHome 23:a50ded45dbaf 1583 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 1584 display.cls();
WiredHome 25:9556a3a9b7cc 1585 display.Backlight_u8(255);
WiredHome 23:a50ded45dbaf 1586 display.puts(0,0, "Text Cursor Test.");
WiredHome 23:a50ded45dbaf 1587
WiredHome 23:a50ded45dbaf 1588 // visible, non-blinking
WiredHome 24:8ca861acf12d 1589 display.SetTextCursor(0,20);
WiredHome 53:86d24b9480b9 1590 display.SetTextCursorControl(RA8875::IBEAM, false);
WiredHome 24:8ca861acf12d 1591 p = iCursor;
WiredHome 23:a50ded45dbaf 1592 while (*p) {
WiredHome 24:8ca861acf12d 1593 display._putc(*p++);
WiredHome 41:2956a0a221e5 1594 wait_ms(delay);
WiredHome 24:8ca861acf12d 1595 }
WiredHome 24:8ca861acf12d 1596
WiredHome 53:86d24b9480b9 1597 display.SetTextCursorControl(RA8875::UNDER, false);
WiredHome 24:8ca861acf12d 1598 p = uCursor;
WiredHome 24:8ca861acf12d 1599 while (*p) {
WiredHome 24:8ca861acf12d 1600 display._putc(*p++);
WiredHome 41:2956a0a221e5 1601 wait_ms(delay);
WiredHome 23:a50ded45dbaf 1602 }
WiredHome 24:8ca861acf12d 1603
WiredHome 53:86d24b9480b9 1604 display.SetTextCursorControl(RA8875::BLOCK, false);
WiredHome 24:8ca861acf12d 1605 p = bCursor;
WiredHome 24:8ca861acf12d 1606 while (*p) {
WiredHome 24:8ca861acf12d 1607 display._putc(*p++);
WiredHome 41:2956a0a221e5 1608 wait_ms(delay);
WiredHome 24:8ca861acf12d 1609 }
WiredHome 24:8ca861acf12d 1610
WiredHome 53:86d24b9480b9 1611 display.SetTextCursorControl(RA8875::BLOCK, true);
WiredHome 24:8ca861acf12d 1612 p = bbCursor;
WiredHome 24:8ca861acf12d 1613 while (*p) {
WiredHome 24:8ca861acf12d 1614 display._putc(*p++);
WiredHome 41:2956a0a221e5 1615 wait_ms(delay);
WiredHome 24:8ca861acf12d 1616 }
WiredHome 41:2956a0a221e5 1617 wait_ms(delay * 20);
WiredHome 53:86d24b9480b9 1618 display.SetTextCursorControl(RA8875::NOCURSOR, false);
WiredHome 23:a50ded45dbaf 1619 }
WiredHome 23:a50ded45dbaf 1620
WiredHome 44:207594dece70 1621
WiredHome 23:a50ded45dbaf 1622 void BacklightTest(RA8875 & display, Serial & pc, float ramptime)
WiredHome 23:a50ded45dbaf 1623 {
WiredHome 29:422616aa04bd 1624 char buf[60];
WiredHome 41:2956a0a221e5 1625 unsigned int w = (ramptime * 1000)/ 256;
WiredHome 41:2956a0a221e5 1626 int delay = 200;
WiredHome 41:2956a0a221e5 1627
WiredHome 41:2956a0a221e5 1628 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 1629 pc.printf("Backlight Test - ramp over %f sec.\r\n", ramptime);
WiredHome 41:2956a0a221e5 1630 else {
WiredHome 41:2956a0a221e5 1631 delay = 0;
WiredHome 41:2956a0a221e5 1632 w = 0;
WiredHome 41:2956a0a221e5 1633 }
WiredHome 23:a50ded45dbaf 1634 display.Backlight_u8(0);
WiredHome 29:422616aa04bd 1635 display.background(White);
WiredHome 23:a50ded45dbaf 1636 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 1637 display.cls();
WiredHome 41:2956a0a221e5 1638 wait_ms(delay);
WiredHome 23:a50ded45dbaf 1639 display.puts(0,0, "RA8875 Backlight Test - Ramp up.");
WiredHome 38:38d503b4fad6 1640 for (int i=0; i <= 255; i++) {
WiredHome 29:422616aa04bd 1641 sprintf(buf, "%3d, %4d", i, w);
WiredHome 37:f19b7e7449dc 1642 display.puts(100,100,buf);
WiredHome 23:a50ded45dbaf 1643 display.Backlight_u8(i);
WiredHome 29:422616aa04bd 1644 wait_ms(w);
WiredHome 23:a50ded45dbaf 1645 }
WiredHome 23:a50ded45dbaf 1646 }
WiredHome 23:a50ded45dbaf 1647
WiredHome 44:207594dece70 1648
WiredHome 23:a50ded45dbaf 1649 void BacklightTest2(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 1650 {
WiredHome 41:2956a0a221e5 1651 int delay = 20;
WiredHome 41:2956a0a221e5 1652
WiredHome 41:2956a0a221e5 1653 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 1654 pc.printf("Backlight Test 2\r\n");
WiredHome 41:2956a0a221e5 1655 else
WiredHome 41:2956a0a221e5 1656 delay = 0;
WiredHome 41:2956a0a221e5 1657
WiredHome 23:a50ded45dbaf 1658 // Dim it out at the end of the tests.
WiredHome 37:f19b7e7449dc 1659 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 1660 display.puts(0,0, "Ramp Backlight down.");
WiredHome 23:a50ded45dbaf 1661 // Ramp it off
WiredHome 23:a50ded45dbaf 1662 for (int i=255; i != 0; i--) {
WiredHome 23:a50ded45dbaf 1663 display.Backlight_u8(i);
WiredHome 41:2956a0a221e5 1664 wait_ms(delay);
WiredHome 23:a50ded45dbaf 1665 }
WiredHome 23:a50ded45dbaf 1666 display.Backlight_u8(0);
WiredHome 23:a50ded45dbaf 1667 }
WiredHome 23:a50ded45dbaf 1668
WiredHome 44:207594dece70 1669
WiredHome 23:a50ded45dbaf 1670 void ExternalFontTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 1671 {
WiredHome 41:2956a0a221e5 1672 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 1673 pc.printf("External Font Test\r\n");
WiredHome 23:a50ded45dbaf 1674 display.background(Black);
WiredHome 23:a50ded45dbaf 1675 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 1676 display.cls();
WiredHome 23:a50ded45dbaf 1677 display.Backlight(1);
WiredHome 37:f19b7e7449dc 1678 display.puts(0,0, "External Font Test.");
WiredHome 37:f19b7e7449dc 1679
WiredHome 37:f19b7e7449dc 1680 display.set_font(Small_6);
WiredHome 37:f19b7e7449dc 1681 display.puts(0,30, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
WiredHome 37:f19b7e7449dc 1682
WiredHome 23:a50ded45dbaf 1683 display.set_font(Arial12x12);
WiredHome 37:f19b7e7449dc 1684 display.puts("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\r\n");
WiredHome 37:f19b7e7449dc 1685 display.set_font(); // restore to internal
WiredHome 37:f19b7e7449dc 1686
WiredHome 37:f19b7e7449dc 1687 display.puts("Normal font again.");
WiredHome 37:f19b7e7449dc 1688 //display.window(0,0, display.width(), display.height());
WiredHome 23:a50ded45dbaf 1689 }
WiredHome 23:a50ded45dbaf 1690
WiredHome 44:207594dece70 1691
WiredHome 23:a50ded45dbaf 1692 void DOSColorTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 1693 {
WiredHome 41:2956a0a221e5 1694 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 1695 pc.printf("DOS Color Test\r\n");
WiredHome 23:a50ded45dbaf 1696 display.background(Black);
WiredHome 23:a50ded45dbaf 1697 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 1698 display.cls();
WiredHome 23:a50ded45dbaf 1699 display.puts(0,0, "DOS Colors - Fore");
WiredHome 23:a50ded45dbaf 1700 display.puts(280,0, "Back");
WiredHome 23:a50ded45dbaf 1701 display.background(Gray);
WiredHome 23:a50ded45dbaf 1702 for (int i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 1703 display.foreground(display.DOSColor(i));
WiredHome 23:a50ded45dbaf 1704 display.puts(160, i*16, display.DOSColorNames(i));
WiredHome 23:a50ded45dbaf 1705 display.background(Black);
WiredHome 23:a50ded45dbaf 1706 }
WiredHome 23:a50ded45dbaf 1707 display.foreground(White);
WiredHome 23:a50ded45dbaf 1708 for (int i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 1709 display.background(display.DOSColor(i));
WiredHome 23:a50ded45dbaf 1710 display.puts(360, i*16, display.DOSColorNames(i));
WiredHome 23:a50ded45dbaf 1711 display.foreground(White);
WiredHome 23:a50ded45dbaf 1712 }
WiredHome 23:a50ded45dbaf 1713 }
WiredHome 23:a50ded45dbaf 1714
WiredHome 44:207594dece70 1715
WiredHome 23:a50ded45dbaf 1716 void WebColorTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 1717 {
WiredHome 41:2956a0a221e5 1718 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 1719 pc.printf("Web Color Test\r\n");
WiredHome 23:a50ded45dbaf 1720 display.background(Black);
WiredHome 23:a50ded45dbaf 1721 display.foreground(Blue);
WiredHome 32:0e4f2ae512e2 1722 display.window(0,0, display.width(), display.height());
WiredHome 23:a50ded45dbaf 1723 display.cls();
WiredHome 59:fb40aad4efd4 1724 display.SetTextFontSize(1,1);
WiredHome 59:fb40aad4efd4 1725 display.puts(200,0, "Web Color Test");
WiredHome 59:fb40aad4efd4 1726 display.SetTextCursor(0,0);
WiredHome 59:fb40aad4efd4 1727 display.puts(" ");
WiredHome 59:fb40aad4efd4 1728 for (int i=0; i<16; i++)
WiredHome 59:fb40aad4efd4 1729 display.printf("%X", i&0xF);
WiredHome 59:fb40aad4efd4 1730 display.puts("\r\n0 ");
WiredHome 23:a50ded45dbaf 1731 for (int i=0; i<sizeof(WebColors)/sizeof(WebColors[0]); i++) {
WiredHome 23:a50ded45dbaf 1732 display.background(WebColors[i]);
WiredHome 23:a50ded45dbaf 1733 display.puts(" ");
WiredHome 59:fb40aad4efd4 1734 if (i % 16 == 15 && i < 255) {
WiredHome 59:fb40aad4efd4 1735 display.printf("\r\n%X ", ((i+1)/16));
WiredHome 59:fb40aad4efd4 1736 }
WiredHome 23:a50ded45dbaf 1737 }
WiredHome 23:a50ded45dbaf 1738 display.SetTextFontSize(1,1);
WiredHome 23:a50ded45dbaf 1739 }
WiredHome 23:a50ded45dbaf 1740
WiredHome 44:207594dece70 1741
WiredHome 37:f19b7e7449dc 1742 void PixelTest(RA8875 & display, Serial & pc)
WiredHome 37:f19b7e7449dc 1743 {
WiredHome 37:f19b7e7449dc 1744 int i, c, x, y;
WiredHome 37:f19b7e7449dc 1745
WiredHome 41:2956a0a221e5 1746 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 1747 pc.printf("Pixel Test\r\n");
WiredHome 37:f19b7e7449dc 1748 display.background(Black);
WiredHome 37:f19b7e7449dc 1749 display.foreground(Blue);
WiredHome 37:f19b7e7449dc 1750 display.cls();
WiredHome 37:f19b7e7449dc 1751 display.puts(0,0, "Pixel Test");
WiredHome 37:f19b7e7449dc 1752 for (i=0; i<1000; i++) {
WiredHome 37:f19b7e7449dc 1753 x = rand() % 480;
WiredHome 37:f19b7e7449dc 1754 y = 16 + rand() % (272-16);
WiredHome 37:f19b7e7449dc 1755 c = rand() % 16;
WiredHome 37:f19b7e7449dc 1756 //pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
WiredHome 37:f19b7e7449dc 1757 display.pixel(x,y, display.DOSColor(c));
WiredHome 37:f19b7e7449dc 1758 }
WiredHome 37:f19b7e7449dc 1759 }
WiredHome 37:f19b7e7449dc 1760
WiredHome 44:207594dece70 1761
WiredHome 23:a50ded45dbaf 1762 void LineTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 1763 {
WiredHome 23:a50ded45dbaf 1764 int i, x, y, x2, y2;
WiredHome 23:a50ded45dbaf 1765
WiredHome 41:2956a0a221e5 1766 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 1767 pc.printf("Line Test\r\n");
WiredHome 23:a50ded45dbaf 1768 display.background(Black);
WiredHome 23:a50ded45dbaf 1769 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 1770 display.cls();
WiredHome 23:a50ded45dbaf 1771 display.puts(0,0, "Line Test");
WiredHome 23:a50ded45dbaf 1772 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 1773 // Lines
WiredHome 23:a50ded45dbaf 1774 x = rand() % 480;
WiredHome 23:a50ded45dbaf 1775 y = rand() % 272;
WiredHome 23:a50ded45dbaf 1776 x2 = rand() % 480;
WiredHome 23:a50ded45dbaf 1777 y2 = rand() % 272;
WiredHome 23:a50ded45dbaf 1778 display.line(x,y, x2,y2, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 1779 }
WiredHome 62:ba5d33438fda 1780 display.foreground(BrightRed);
WiredHome 62:ba5d33438fda 1781 display.foreground(BrightGreen);
WiredHome 62:ba5d33438fda 1782 display.foreground(BrightBlue);
WiredHome 62:ba5d33438fda 1783 display.line(55,50, 79,74, BrightRed);
WiredHome 62:ba5d33438fda 1784 display.line(57,50, 81,74, BrightGreen);
WiredHome 62:ba5d33438fda 1785 display.line(59,50, 83,74, BrightBlue);
WiredHome 62:ba5d33438fda 1786 // horz
WiredHome 62:ba5d33438fda 1787 display.line(30,40, 32,40, BrightRed);
WiredHome 62:ba5d33438fda 1788 display.line(30,42, 32,42, BrightGreen);
WiredHome 62:ba5d33438fda 1789 display.line(30,44, 32,44, BrightBlue);
WiredHome 62:ba5d33438fda 1790 // vert
WiredHome 62:ba5d33438fda 1791 display.line(20,40, 20,42, BrightRed);
WiredHome 62:ba5d33438fda 1792 display.line(22,40, 22,42, BrightGreen);
WiredHome 62:ba5d33438fda 1793 display.line(24,40, 24,42, BrightBlue);
WiredHome 62:ba5d33438fda 1794 // compare point to line-point
WiredHome 62:ba5d33438fda 1795 display.pixel(20,50, BrightRed);
WiredHome 62:ba5d33438fda 1796 display.pixel(22,50, BrightGreen);
WiredHome 62:ba5d33438fda 1797 display.pixel(24,50, BrightBlue);
WiredHome 62:ba5d33438fda 1798 display.line(20,52, 20,52, BrightRed);
WiredHome 62:ba5d33438fda 1799 display.line(22,52, 22,52, BrightGreen);
WiredHome 62:ba5d33438fda 1800 display.line(24,52, 24,52, BrightBlue);
WiredHome 62:ba5d33438fda 1801
WiredHome 62:ba5d33438fda 1802 // point
WiredHome 62:ba5d33438fda 1803 display.line(50,50, 50,50, Red);
WiredHome 62:ba5d33438fda 1804 display.line(52,52, 52,52, Green);
WiredHome 62:ba5d33438fda 1805 display.line(54,54, 54,54, Blue);
WiredHome 62:ba5d33438fda 1806 display.line(60,60, 60,60, BrightRed);
WiredHome 62:ba5d33438fda 1807 display.line(62,62, 62,62, BrightGreen);
WiredHome 62:ba5d33438fda 1808 display.line(64,64, 64,64, BrightBlue);
WiredHome 62:ba5d33438fda 1809 display.line(70,70, 70,70, DarkRed);
WiredHome 62:ba5d33438fda 1810 display.line(72,72, 72,72, DarkGreen);
WiredHome 62:ba5d33438fda 1811 display.line(74,74, 74,74, DarkBlue);
WiredHome 23:a50ded45dbaf 1812 }
WiredHome 23:a50ded45dbaf 1813
WiredHome 44:207594dece70 1814
WiredHome 23:a50ded45dbaf 1815 void RectangleTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 1816 {
WiredHome 23:a50ded45dbaf 1817 int i, x1,y1, x2,y2;
WiredHome 23:a50ded45dbaf 1818
WiredHome 41:2956a0a221e5 1819 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 1820 pc.printf("Rectangle Test\r\n");
WiredHome 23:a50ded45dbaf 1821 display.background(Black);
WiredHome 23:a50ded45dbaf 1822 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 1823 display.cls();
WiredHome 23:a50ded45dbaf 1824 display.puts(0,0, "Rectangle Test");
WiredHome 23:a50ded45dbaf 1825 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 1826 x1 = rand() % 240;
WiredHome 23:a50ded45dbaf 1827 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 1828 x2 = rand() % 240;
WiredHome 23:a50ded45dbaf 1829 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 1830 display.rect(x1,y1, x2,y2, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 1831
WiredHome 23:a50ded45dbaf 1832 x1 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 1833 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 1834 x2 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 1835 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 1836 display.rect(x1,y1, x2,y2, FILL);
WiredHome 23:a50ded45dbaf 1837 }
WiredHome 23:a50ded45dbaf 1838 }
WiredHome 23:a50ded45dbaf 1839
WiredHome 44:207594dece70 1840
WiredHome 44:207594dece70 1841 void LayerTest(RA8875 & display, Serial & pc)
WiredHome 44:207594dece70 1842 {
WiredHome 44:207594dece70 1843 loc_t i, x1,y1, x2,y2, r1,r2;
WiredHome 44:207594dece70 1844
WiredHome 44:207594dece70 1845 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 1846 pc.printf("Layer Test\r\n");
WiredHome 44:207594dece70 1847
WiredHome 50:2c4f474a2453 1848 display.SelectDrawingLayer(0);
WiredHome 44:207594dece70 1849 display.background(Black);
WiredHome 44:207594dece70 1850 display.foreground(Blue);
WiredHome 44:207594dece70 1851 display.cls();
WiredHome 44:207594dece70 1852 display.puts(0,0, "Layer 0");
WiredHome 44:207594dece70 1853 for (i=0; i<16; i++) {
WiredHome 44:207594dece70 1854 x1 = rand() % 240;
WiredHome 44:207594dece70 1855 y1 = 50 + rand() % 200;
WiredHome 44:207594dece70 1856 x2 = x1 + rand() % 100;
WiredHome 44:207594dece70 1857 y2 = y1 + rand() % 100;
WiredHome 44:207594dece70 1858 r1 = rand() % (x2 - x1)/2;
WiredHome 44:207594dece70 1859 r2 = rand() % (y2 - y1)/2;
WiredHome 44:207594dece70 1860 display.roundrect(x1,y1, x2,y2, r1,r2, display.DOSColor(i));
WiredHome 44:207594dece70 1861 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 1862 wait_ms(20);
WiredHome 44:207594dece70 1863 }
WiredHome 44:207594dece70 1864 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 1865 wait_ms(1000);
WiredHome 44:207594dece70 1866
WiredHome 50:2c4f474a2453 1867 display.SelectDrawingLayer(1);
WiredHome 44:207594dece70 1868 display.background(Black);
WiredHome 44:207594dece70 1869 display.foreground(Yellow);
WiredHome 44:207594dece70 1870 display.cls();
WiredHome 44:207594dece70 1871 display.puts(240,0, "Layer 1");
WiredHome 44:207594dece70 1872 for (i=0; i<16; i++) {
WiredHome 44:207594dece70 1873 x1 = 300 + rand() % 100;
WiredHome 44:207594dece70 1874 y1 = 70 + rand() % 200;
WiredHome 44:207594dece70 1875 r1 = rand() % min(y1 - 20, 100);
WiredHome 44:207594dece70 1876 display.circle(x1,y1,r1, display.DOSColor(i));
WiredHome 44:207594dece70 1877 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 1878 wait_ms(20);
WiredHome 44:207594dece70 1879 }
WiredHome 56:7a85d226ad0d 1880 display.SetLayerMode(RA8875::ShowLayer1); // Show it after the build-up
WiredHome 44:207594dece70 1881 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 1882 wait_ms(2000);
WiredHome 44:207594dece70 1883
WiredHome 50:2c4f474a2453 1884 display.SelectDrawingLayer(0);
WiredHome 56:7a85d226ad0d 1885 display.SetLayerMode(RA8875::ShowLayer0); // Show Layer 0 again
WiredHome 44:207594dece70 1886 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 1887 wait_ms(1000);
WiredHome 53:86d24b9480b9 1888 display.SetLayerMode(RA8875::TransparentMode); // Transparent mode
WiredHome 44:207594dece70 1889 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 1890 wait_ms(1000);
WiredHome 44:207594dece70 1891 for (i=0; i<=8; i++) {
WiredHome 44:207594dece70 1892 display.SetLayerTransparency(i, 8-i);
WiredHome 44:207594dece70 1893 if (!SuppressSlowStuff)
WiredHome 44:207594dece70 1894 wait_ms(200);
WiredHome 44:207594dece70 1895 }
WiredHome 44:207594dece70 1896
WiredHome 44:207594dece70 1897 // Restore before we exit
WiredHome 44:207594dece70 1898 display.SetLayerTransparency(0, 0);
WiredHome 56:7a85d226ad0d 1899 display.SetLayerMode(RA8875::ShowLayer0); // Restore to layer 0
WiredHome 44:207594dece70 1900 }
WiredHome 44:207594dece70 1901
WiredHome 44:207594dece70 1902
WiredHome 23:a50ded45dbaf 1903 void RoundRectTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 1904 {
WiredHome 37:f19b7e7449dc 1905 loc_t i, x1,y1, x2,y2, r1,r2;
WiredHome 23:a50ded45dbaf 1906
WiredHome 41:2956a0a221e5 1907 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 1908 pc.printf("Round Rectangle Test\r\n");
WiredHome 23:a50ded45dbaf 1909 display.background(Black);
WiredHome 23:a50ded45dbaf 1910 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 1911 display.cls();
WiredHome 23:a50ded45dbaf 1912 display.puts(0,0, "Rounded Rectangle Test");
WiredHome 23:a50ded45dbaf 1913
WiredHome 23:a50ded45dbaf 1914 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 1915 x1 = rand() % 240;
WiredHome 23:a50ded45dbaf 1916 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 1917 x2 = x1 + rand() % 100;
WiredHome 23:a50ded45dbaf 1918 y2 = y1 + rand() % 100;
WiredHome 23:a50ded45dbaf 1919 r1 = rand() % (x2 - x1)/2;
WiredHome 23:a50ded45dbaf 1920 r2 = rand() % (y2 - y1)/2;
WiredHome 23:a50ded45dbaf 1921 display.roundrect(x1,y1, x2,y2, 5,8, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 1922
WiredHome 23:a50ded45dbaf 1923 x1 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 1924 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 1925 x2 = x1 + rand() % 100;
WiredHome 23:a50ded45dbaf 1926 y2 = y1 + rand() % 100;
WiredHome 23:a50ded45dbaf 1927 r1 = rand() % (x2 - x1)/2;
WiredHome 23:a50ded45dbaf 1928 r2 = rand() % (y2 - y1)/2;
WiredHome 23:a50ded45dbaf 1929 display.roundrect(x1,y1, x2,y2, r1,r2, FILL);
WiredHome 23:a50ded45dbaf 1930 }
WiredHome 23:a50ded45dbaf 1931 }
WiredHome 23:a50ded45dbaf 1932
WiredHome 44:207594dece70 1933
WiredHome 23:a50ded45dbaf 1934 void TriangleTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 1935 {
WiredHome 23:a50ded45dbaf 1936 int i, x1, y1, x2, y2, x3, y3;
WiredHome 23:a50ded45dbaf 1937
WiredHome 41:2956a0a221e5 1938 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 1939 pc.printf("Triangle Test\r\n");
WiredHome 23:a50ded45dbaf 1940 display.background(Black);
WiredHome 23:a50ded45dbaf 1941 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 1942 display.cls();
WiredHome 23:a50ded45dbaf 1943 display.puts(0,0, "Triangle Test");
WiredHome 23:a50ded45dbaf 1944
WiredHome 23:a50ded45dbaf 1945 x1 = 150;
WiredHome 23:a50ded45dbaf 1946 y1 = 2;
WiredHome 23:a50ded45dbaf 1947 x2 = 190;
WiredHome 23:a50ded45dbaf 1948 y2 = 7;
WiredHome 23:a50ded45dbaf 1949 x3 = 170;
WiredHome 23:a50ded45dbaf 1950 y3 = 16;
WiredHome 23:a50ded45dbaf 1951 display.triangle(x1,y1, x2,y2, x3,y3);
WiredHome 23:a50ded45dbaf 1952
WiredHome 23:a50ded45dbaf 1953 x1 = 200;
WiredHome 23:a50ded45dbaf 1954 y1 = 2;
WiredHome 23:a50ded45dbaf 1955 x2 = 240;
WiredHome 23:a50ded45dbaf 1956 y2 = 7;
WiredHome 23:a50ded45dbaf 1957 x3 = 220;
WiredHome 23:a50ded45dbaf 1958 y3 = 16;
WiredHome 23:a50ded45dbaf 1959 display.filltriangle(x1,y1, x2,y2, x3,y3, BrightRed);
WiredHome 23:a50ded45dbaf 1960
WiredHome 23:a50ded45dbaf 1961 x1 = 300;
WiredHome 23:a50ded45dbaf 1962 y1 = 2;
WiredHome 23:a50ded45dbaf 1963 x2 = 340;
WiredHome 23:a50ded45dbaf 1964 y2 = 7;
WiredHome 23:a50ded45dbaf 1965 x3 = 320;
WiredHome 23:a50ded45dbaf 1966 y3 = 16;
WiredHome 23:a50ded45dbaf 1967 display.triangle(x1,y1, x2,y2, x3,y3, NOFILL);
WiredHome 23:a50ded45dbaf 1968
WiredHome 23:a50ded45dbaf 1969 x1 = 400;
WiredHome 23:a50ded45dbaf 1970 y1 = 2;
WiredHome 23:a50ded45dbaf 1971 x2 = 440;
WiredHome 23:a50ded45dbaf 1972 y2 = 7;
WiredHome 23:a50ded45dbaf 1973 x3 = 420;
WiredHome 23:a50ded45dbaf 1974 y3 = 16;
WiredHome 23:a50ded45dbaf 1975 display.triangle(x1,y1, x2,y2, x3,y3, Blue);
WiredHome 23:a50ded45dbaf 1976
WiredHome 23:a50ded45dbaf 1977 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 1978 x1 = rand() % 240;
WiredHome 23:a50ded45dbaf 1979 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 1980 x2 = rand() % 240;
WiredHome 23:a50ded45dbaf 1981 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 1982 x3 = rand() % 240;
WiredHome 23:a50ded45dbaf 1983 y3 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 1984 display.triangle(x1,y1, x2,y2, x3,y3, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 1985 x1 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 1986 y1 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 1987 x2 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 1988 y2 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 1989 x3 = 240 + rand() % 240;
WiredHome 23:a50ded45dbaf 1990 y3 = 50 + rand() % 200;
WiredHome 23:a50ded45dbaf 1991 display.triangle(x1,y1, x2,y2, x3,y3, FILL);
WiredHome 23:a50ded45dbaf 1992 }
WiredHome 23:a50ded45dbaf 1993 }
WiredHome 23:a50ded45dbaf 1994
WiredHome 44:207594dece70 1995
WiredHome 23:a50ded45dbaf 1996 void CircleTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 1997 {
WiredHome 23:a50ded45dbaf 1998 int i, x, y, r1;
WiredHome 23:a50ded45dbaf 1999
WiredHome 41:2956a0a221e5 2000 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2001 pc.printf("Circle Test\r\n");
WiredHome 23:a50ded45dbaf 2002 display.background(Black);
WiredHome 23:a50ded45dbaf 2003 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2004 display.cls();
WiredHome 23:a50ded45dbaf 2005 display.puts(0,0, "Circle Test");
WiredHome 23:a50ded45dbaf 2006 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2007 x = 100 + rand() % 100;
WiredHome 23:a50ded45dbaf 2008 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2009 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2010 //pc.printf(" (%d,%d) - %d\r\n", x,y,r1);
WiredHome 23:a50ded45dbaf 2011 display.circle(x,y,r1, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2012
WiredHome 23:a50ded45dbaf 2013 x = 300 + rand() % 100;
WiredHome 23:a50ded45dbaf 2014 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2015 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2016 //pc.printf(" (%d,%d) - %d FILL\r\n", x,y,r1);
WiredHome 23:a50ded45dbaf 2017 display.circle(x,y,r1, display.DOSColor(i), FILL);
WiredHome 23:a50ded45dbaf 2018 }
WiredHome 23:a50ded45dbaf 2019 }
WiredHome 23:a50ded45dbaf 2020
WiredHome 44:207594dece70 2021
WiredHome 23:a50ded45dbaf 2022 void EllipseTest(RA8875 & display, Serial & pc)
WiredHome 23:a50ded45dbaf 2023 {
WiredHome 23:a50ded45dbaf 2024 int i,x,y,r1,r2;
WiredHome 23:a50ded45dbaf 2025
WiredHome 41:2956a0a221e5 2026 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2027 pc.printf("Ellipse Test\r\n");
WiredHome 23:a50ded45dbaf 2028 display.background(Black);
WiredHome 23:a50ded45dbaf 2029 display.foreground(Blue);
WiredHome 23:a50ded45dbaf 2030 display.cls();
WiredHome 23:a50ded45dbaf 2031 display.puts(0,0, "Ellipse Test");
WiredHome 23:a50ded45dbaf 2032 for (i=0; i<16; i++) {
WiredHome 23:a50ded45dbaf 2033 x = 100 + rand() % 100;
WiredHome 23:a50ded45dbaf 2034 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2035 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2036 r2 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2037 display.ellipse(x,y,r1,r2, display.DOSColor(i));
WiredHome 23:a50ded45dbaf 2038
WiredHome 23:a50ded45dbaf 2039 x = 300 + rand() % 100;
WiredHome 23:a50ded45dbaf 2040 y = 70 + rand() % 200;
WiredHome 23:a50ded45dbaf 2041 r1 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2042 r2 = rand() % min(y - 20, 100);
WiredHome 23:a50ded45dbaf 2043 display.ellipse(x,y,r1,r2, FILL);
WiredHome 23:a50ded45dbaf 2044 }
WiredHome 23:a50ded45dbaf 2045 }
WiredHome 23:a50ded45dbaf 2046
WiredHome 44:207594dece70 2047
WiredHome 37:f19b7e7449dc 2048 void TestGraphicsBitmap(RA8875 & display, Serial & pc)
WiredHome 37:f19b7e7449dc 2049 {
WiredHome 37:f19b7e7449dc 2050 LocalFileSystem local("local");
WiredHome 41:2956a0a221e5 2051 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2052 pc.printf("Bitmap File Load\r\n");
WiredHome 37:f19b7e7449dc 2053 display.background(Black);
WiredHome 37:f19b7e7449dc 2054 display.foreground(Blue);
WiredHome 37:f19b7e7449dc 2055 display.cls();
WiredHome 37:f19b7e7449dc 2056 display.puts(0,0, "Graphics Test, loading /local/TestPat.bmp");
WiredHome 37:f19b7e7449dc 2057 wait(3);
WiredHome 37:f19b7e7449dc 2058
WiredHome 37:f19b7e7449dc 2059 int r = display.RenderBitmapFile(0,0, "/local/TestPat.bmp");
WiredHome 59:fb40aad4efd4 2060 if (!SuppressSlowStuff)
WiredHome 59:fb40aad4efd4 2061 pc.printf(" returned %d\r\n", r);
WiredHome 37:f19b7e7449dc 2062 }
WiredHome 37:f19b7e7449dc 2063
WiredHome 44:207594dece70 2064
WiredHome 41:2956a0a221e5 2065 void SpeedTest(RA8875 & display, Serial & pc)
WiredHome 41:2956a0a221e5 2066 {
WiredHome 41:2956a0a221e5 2067 Timer t;
WiredHome 41:2956a0a221e5 2068 SuppressSlowStuff = true;
WiredHome 41:2956a0a221e5 2069 pc.printf("\r\nSpeedTest disables delays, runs tests, reports overall time.\r\n");
WiredHome 41:2956a0a221e5 2070 t.start();
WiredHome 41:2956a0a221e5 2071 // do stuff fast
WiredHome 41:2956a0a221e5 2072 TextCursorTest(display, pc);
WiredHome 49:c5182231d1b9 2073 TextWrapTest(display, pc);
WiredHome 41:2956a0a221e5 2074 BacklightTest(display, pc, 0);
WiredHome 41:2956a0a221e5 2075 BacklightTest2(display, pc);
WiredHome 41:2956a0a221e5 2076 ExternalFontTest(display, pc);
WiredHome 41:2956a0a221e5 2077 DOSColorTest(display, pc);
WiredHome 41:2956a0a221e5 2078 WebColorTest(display, pc);
WiredHome 41:2956a0a221e5 2079 PixelTest(display, pc);
WiredHome 41:2956a0a221e5 2080 LineTest(display, pc);
WiredHome 41:2956a0a221e5 2081 RectangleTest(display, pc);
WiredHome 41:2956a0a221e5 2082 RoundRectTest(display, pc);
WiredHome 41:2956a0a221e5 2083 TriangleTest(display, pc);
WiredHome 41:2956a0a221e5 2084 CircleTest(display, pc);
WiredHome 41:2956a0a221e5 2085 EllipseTest(display, pc);
WiredHome 44:207594dece70 2086 LayerTest(display, pc);
WiredHome 41:2956a0a221e5 2087 //TestGraphicsBitmap(display, pc);
WiredHome 41:2956a0a221e5 2088 pc.printf("SpeedTest completed in %d msec\r\n", t.read_ms());
WiredHome 44:207594dece70 2089 #ifdef PERF_METRICS
WiredHome 41:2956a0a221e5 2090 display.ReportPerformance(pc);
WiredHome 41:2956a0a221e5 2091 #endif
WiredHome 41:2956a0a221e5 2092 SuppressSlowStuff = false;
WiredHome 41:2956a0a221e5 2093 }
WiredHome 41:2956a0a221e5 2094
WiredHome 44:207594dece70 2095
WiredHome 41:2956a0a221e5 2096 void PrintScreen(RA8875 & display, Serial & pc)
WiredHome 41:2956a0a221e5 2097 {
WiredHome 41:2956a0a221e5 2098 LocalFileSystem local("local");
WiredHome 41:2956a0a221e5 2099 if (!SuppressSlowStuff)
WiredHome 41:2956a0a221e5 2100 pc.printf("PrintScreen\r\n");
WiredHome 41:2956a0a221e5 2101 display.PrintScreen( 0,0, 480,272, "/local/Capture.bmp");
WiredHome 41:2956a0a221e5 2102 }
WiredHome 41:2956a0a221e5 2103
WiredHome 44:207594dece70 2104
WiredHome 23:a50ded45dbaf 2105 void RunTestSet(RA8875 & lcd, Serial & pc)
WiredHome 23:a50ded45dbaf 2106 {
WiredHome 23:a50ded45dbaf 2107 int q = 0;
WiredHome 23:a50ded45dbaf 2108 int automode = 0;
WiredHome 49:c5182231d1b9 2109 const unsigned char modelist[] = "BDWtGLlFROTPCEbw"; // auto-test in this order.
WiredHome 23:a50ded45dbaf 2110
WiredHome 23:a50ded45dbaf 2111 while(1) {
WiredHome 23:a50ded45dbaf 2112 pc.printf("\r\n"
WiredHome 41:2956a0a221e5 2113 "B - Backlight up b - backlight dim\r\n"
WiredHome 41:2956a0a221e5 2114 "D - DOS Colors W - Web Colors\r\n"
WiredHome 41:2956a0a221e5 2115 "t - text cursor G - Graphics Bitmap\r\n"
WiredHome 41:2956a0a221e5 2116 "L - Lines F - external Font\r\n"
WiredHome 41:2956a0a221e5 2117 "R - Rectangles O - rOund rectangles\r\n"
WiredHome 41:2956a0a221e5 2118 "T - Triangles P - Pixels \r\n"
WiredHome 41:2956a0a221e5 2119 "C - Circles E - Ellipses\r\n"
WiredHome 41:2956a0a221e5 2120 "A - Auto Test mode S - Speed Test\r\n"
WiredHome 41:2956a0a221e5 2121 "p - print screen r - reset \r\n"
WiredHome 49:c5182231d1b9 2122 "l - layer test w - wrapping text \r\n"
WiredHome 58:26658a56112a 2123 #ifdef PERF_METRICS
WiredHome 41:2956a0a221e5 2124 "0 - clear performance 1 - report performance\r\n"
WiredHome 41:2956a0a221e5 2125 #endif
WiredHome 23:a50ded45dbaf 2126 "> ");
WiredHome 23:a50ded45dbaf 2127 if (automode == -1 || pc.readable()) {
WiredHome 23:a50ded45dbaf 2128 automode = -1;
WiredHome 37:f19b7e7449dc 2129 q = pc.getc();
WiredHome 37:f19b7e7449dc 2130 while (pc.readable())
WiredHome 37:f19b7e7449dc 2131 pc.getc();
WiredHome 23:a50ded45dbaf 2132 } else if (automode >= 0) {
WiredHome 23:a50ded45dbaf 2133 q = modelist[automode];
WiredHome 23:a50ded45dbaf 2134 }
WiredHome 23:a50ded45dbaf 2135 switch(q) {
WiredHome 58:26658a56112a 2136 #ifdef PERF_METRICS
WiredHome 41:2956a0a221e5 2137 case '0':
WiredHome 41:2956a0a221e5 2138 lcd.ClearPerformance();
WiredHome 41:2956a0a221e5 2139 break;
WiredHome 41:2956a0a221e5 2140 case '1':
WiredHome 41:2956a0a221e5 2141 lcd.ReportPerformance(pc);
WiredHome 41:2956a0a221e5 2142 break;
WiredHome 41:2956a0a221e5 2143 #endif
WiredHome 23:a50ded45dbaf 2144 case 'A':
WiredHome 23:a50ded45dbaf 2145 automode = 0;
WiredHome 23:a50ded45dbaf 2146 break;
WiredHome 23:a50ded45dbaf 2147 case 'B':
WiredHome 41:2956a0a221e5 2148 BacklightTest(lcd, pc, 2);
WiredHome 23:a50ded45dbaf 2149 break;
WiredHome 23:a50ded45dbaf 2150 case 'b':
WiredHome 23:a50ded45dbaf 2151 BacklightTest2(lcd, pc);
WiredHome 23:a50ded45dbaf 2152 break;
WiredHome 23:a50ded45dbaf 2153 case 'D':
WiredHome 23:a50ded45dbaf 2154 DOSColorTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2155 break;
WiredHome 23:a50ded45dbaf 2156 case 'W':
WiredHome 23:a50ded45dbaf 2157 WebColorTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2158 break;
WiredHome 23:a50ded45dbaf 2159 case 't':
WiredHome 23:a50ded45dbaf 2160 TextCursorTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2161 break;
WiredHome 49:c5182231d1b9 2162 case 'w':
WiredHome 49:c5182231d1b9 2163 TextWrapTest(lcd, pc);
WiredHome 49:c5182231d1b9 2164 break;
WiredHome 23:a50ded45dbaf 2165 case 'F':
WiredHome 23:a50ded45dbaf 2166 ExternalFontTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2167 break;
WiredHome 23:a50ded45dbaf 2168 case 'L':
WiredHome 23:a50ded45dbaf 2169 LineTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2170 break;
WiredHome 44:207594dece70 2171 case 'l':
WiredHome 44:207594dece70 2172 LayerTest(lcd, pc);
WiredHome 44:207594dece70 2173 break;
WiredHome 23:a50ded45dbaf 2174 case 'R':
WiredHome 23:a50ded45dbaf 2175 RectangleTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2176 break;
WiredHome 23:a50ded45dbaf 2177 case 'O':
WiredHome 23:a50ded45dbaf 2178 RoundRectTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2179 break;
WiredHome 41:2956a0a221e5 2180 case 'p':
WiredHome 41:2956a0a221e5 2181 PrintScreen(lcd, pc);
WiredHome 41:2956a0a221e5 2182 break;
WiredHome 41:2956a0a221e5 2183 case 'S':
WiredHome 41:2956a0a221e5 2184 SpeedTest(lcd, pc);
WiredHome 41:2956a0a221e5 2185 break;
WiredHome 23:a50ded45dbaf 2186 case 'T':
WiredHome 23:a50ded45dbaf 2187 TriangleTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2188 break;
WiredHome 37:f19b7e7449dc 2189 case 'P':
WiredHome 37:f19b7e7449dc 2190 PixelTest(lcd, pc);
WiredHome 37:f19b7e7449dc 2191 break;
WiredHome 37:f19b7e7449dc 2192 case 'G':
WiredHome 37:f19b7e7449dc 2193 TestGraphicsBitmap(lcd, pc);
WiredHome 37:f19b7e7449dc 2194 break;
WiredHome 23:a50ded45dbaf 2195 case 'C':
WiredHome 23:a50ded45dbaf 2196 CircleTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2197 break;
WiredHome 23:a50ded45dbaf 2198 case 'E':
WiredHome 23:a50ded45dbaf 2199 EllipseTest(lcd, pc);
WiredHome 23:a50ded45dbaf 2200 break;
WiredHome 23:a50ded45dbaf 2201 case 'r':
WiredHome 23:a50ded45dbaf 2202 pc.printf("Resetting ...\r\n");
WiredHome 23:a50ded45dbaf 2203 wait_ms(20);
WiredHome 23:a50ded45dbaf 2204 mbed_reset();
WiredHome 23:a50ded45dbaf 2205 break;
WiredHome 23:a50ded45dbaf 2206 default:
WiredHome 23:a50ded45dbaf 2207 printf("huh?\n");
WiredHome 23:a50ded45dbaf 2208 break;
WiredHome 23:a50ded45dbaf 2209 }
WiredHome 23:a50ded45dbaf 2210 if (automode >= 0) {
WiredHome 23:a50ded45dbaf 2211 automode++;
WiredHome 23:a50ded45dbaf 2212 if (automode >= sizeof(modelist))
WiredHome 23:a50ded45dbaf 2213 automode = 0;
WiredHome 23:a50ded45dbaf 2214 wait_ms(2000);
WiredHome 23:a50ded45dbaf 2215 }
WiredHome 23:a50ded45dbaf 2216 wait_ms(200);
WiredHome 23:a50ded45dbaf 2217 }
WiredHome 23:a50ded45dbaf 2218 }
WiredHome 23:a50ded45dbaf 2219
WiredHome 23:a50ded45dbaf 2220 #endif // TESTENABLE