RA8875 - Library to control a Graphics TFT connected to 4-…

Users » WiredHome » Code » RA8875

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

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@164:76edd7d9cb68, 2019-02-14 (annotated)

Committer:: WiredHome
Date:: Thu Feb 14 12:34:52 2019 +0000
Revision:: 164:76edd7d9cb68
Parent:: 163:17526689a3ed
Child:: 165:695c24cc5197

PrintScreen - 24-bit or 8-bit BMP format support. Improved documentation to the palette and the performance factors.

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	12 Jan 2014
Imports:	363
Forks:	7
Commits:	210
Dependents:	20
Dependencies:	0
Followers:	13
Issues:	2

The code in this repository is MIT licensed.

Components

RA8875: 4" to 8" (WQVGA, WVGA, Multi-Touch, Keypad)